From fe70153bffac15f0e04503510b1cd0d82f90eca7 Mon Sep 17 00:00:00 2001 From: lils <310442317+linsheng-li@users.noreply.github.com> Date: Tue, 20 Oct 2026 11:43:32 +0800 Subject: [PATCH] fix(memory): decode JSON-encoded internal_info metadata --- src/memos/memories/textual/item.py | 10 ++++ tests/memories/textual/test_item.py | 91 +++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 tests/memories/textual/test_item.py diff --git a/src/memos/memories/textual/item.py b/src/memos/memories/textual/item.py index 23474cc20..9ad5369e7 100644 --- a/src/memos/memories/textual/item.py +++ b/src/memos/memories/textual/item.py @@ -159,6 +159,16 @@ class TextualMemoryMetadata(BaseModel): description="Internal algorithm metadata reserved for system use.", ) + @field_validator("internal_info", mode="before") + @classmethod + def _decode_internal_info(cls, value: Any) -> Any: + # Neo4j stores dictionaries as JSON strings; decode them before model validation. + if isinstance(value, str): + value = json.loads(value) + if not isinstance(value, dict): + raise ValueError("internal_info JSON must decode to an object") + return value + model_config = ConfigDict(extra="allow") covered_history: Any | None = Field( diff --git a/tests/memories/textual/test_item.py b/tests/memories/textual/test_item.py new file mode 100644 index 000000000..71c206742 --- /dev/null +++ b/tests/memories/textual/test_item.py @@ -0,0 +1,91 @@ +"""Regression tests for JSON-encoded internal metadata read from graph storage.""" + +import copy +import json +import uuid + +import pytest + +from pydantic import ValidationError + +from memos.memories.textual.item import ( + PreferenceTextualMemoryMetadata, + SearchedTreeNodeTextualMemoryMetadata, + TextualMemoryItem, + TextualMemoryMetadata, + TreeNodeTextualMemoryMetadata, +) + + +@pytest.mark.parametrize( + "metadata_cls", + [ + TextualMemoryMetadata, + TreeNodeTextualMemoryMetadata, + SearchedTreeNodeTextualMemoryMetadata, + PreferenceTextualMemoryMetadata, + ], +) +def test_internal_info_decodes_json_object(metadata_cls): + value = {"ingest_batch_id": "test-batch", "nested": {"chunk_index": 0, "values": [True, None]}} + + metadata = metadata_cls(internal_info=json.dumps(value)) + + assert metadata.internal_info == value + assert metadata.model_dump()["internal_info"] == value + + +@pytest.mark.parametrize("value", [None, {}, {"ingest_batch_id": "test-batch", "nested": [1, 2]}]) +def test_internal_info_preserves_existing_values(value): + original = copy.deepcopy(value) + + metadata = TextualMemoryMetadata(internal_info=value) + + assert metadata.internal_info == original + assert value == original + + +@pytest.mark.parametrize( + "value", + ["{", "not-json", "[]", "null", "1", "true", '"text"', json.dumps('{"batch": "test"}')], +) +def test_internal_info_rejects_malformed_json_and_encoded_non_objects(value): + with pytest.raises(ValidationError): + TextualMemoryMetadata(internal_info=value) + + +@pytest.mark.parametrize("value", [[], [["batch", "test"]], 1, False]) +def test_internal_info_preserves_rejection_of_invalid_types(value): + with pytest.raises(ValidationError): + TextualMemoryMetadata(internal_info=value) + + +def test_search_item_from_dict_decodes_internal_info_without_changing_other_fields(): + value = {"ingest_batch_id": "test-batch", "chunk_index": 0, "chunk_total": 2} + record = { + "id": str(uuid.uuid4()), + "memory": "Synthetic memory for a graph storage round trip.", + "metadata": { + "memory_type": "LongTermMemory", + "internal_info": json.dumps(value), + "relativity": 0.75, + "sources": [{"type": "chat", "role": "user", "content": "Synthetic source."}], + "session_id": "test-session", + }, + } + original = copy.deepcopy(record) + + item = TextualMemoryItem.from_dict(record) + + assert item.metadata.internal_info == value + assert item.id == record["id"] + assert item.memory == record["memory"] + assert item.metadata.sources[0].content == "Synthetic source." + assert item.metadata.session_id == "test-session" + assert item.metadata.relativity == 0.75 + assert record == original + + # Graph storage serializes dictionaries as JSON strings again on the next write. + stored = item.to_dict() + stored["metadata"]["internal_info"] = json.dumps(stored["metadata"]["internal_info"]) + assert TextualMemoryItem.from_dict(stored).to_dict() == item.to_dict()