better persistent memory fix

src/lilith_agent/memory.py

@@ -13,6 +13,34 @@ log = logging.getLogger(__name__)
 LILITH_HOME = Path(os.getenv("LILITH_HOME", ".lilith"))
 MEMORY_DB_PATH = LILITH_HOME / "long_term_memory.sqlite"
 
+def _content_to_text(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict):
+                text = item.get("text")
+                if text is not None:
+                    parts.append(str(text))
+                elif "content" in item:
+                    nested = _content_to_text(item["content"])
+                    if nested:
+                        parts.append(nested)
+            else:
+                parts.append(str(item))
+        return "\n".join(part for part in parts if part)
+    return str(content)
+
+def _memory_content_to_text(content: Any) -> str:
+    if hasattr(content, "content"):
+        return _content_to_text(content.content)
+    return _content_to_text(content)
+
 class MemoryStore:
     def __init__(self, db_path: Path = MEMORY_DB_PATH):
         self.db_path = db_path
@@ -95,8 +123,7 @@ def extract_and_compress_facts(messages: List[BaseMessage], model) -> None:
     try:
         # 1. Get existing memories from our local store
         existing_rows = _store.get_all_memories()
-        # langmem manager expects a list of dictionaries or objects matching the schema
-        existing_memories = [{"content": m["content"]} for m in existing_rows]
+        existing_memories = [m["content"] for m in existing_rows]
 
         # 2. Initialize langmem manager (it's a Runnable)
         # We use the default schema which is basically content strings
@@ -118,13 +145,13 @@ def extract_and_compress_facts(messages: List[BaseMessage], model) -> None:
                 # result elements can be ExtractedMemory objects or simple dicts
                 content = getattr(item, "content", None) or (item[1] if isinstance(item, tuple) else item.get("content"))
                 if content:
-                    updated_facts.append({"content": str(content)})
+                    updated_facts.append({"content": _memory_content_to_text(content)})
             
             _store.save_memories(updated_facts)
             log.info(f"[memory] langmem updated store to {len(updated_facts)} facts.")
 
-    except Exception as e:
-        log.error(f"[memory] langmem extraction failed: {e}")
+    except Exception:
+        log.exception("[memory] langmem extraction failed")
         # Fallback to summarize episode if manager fails
         summarize_episode(messages, model)
 
@@ -135,15 +162,17 @@ def summarize_episode(messages: List[BaseMessage], model) -> None:
         initial_question = ""
         outcome = "success"
         for m in messages:
+            content = _content_to_text(m.content)
             if isinstance(m, HumanMessage) and not initial_question:
-                initial_question = str(m.content)
-            if "ERROR" in str(m.content).upper():
+                initial_question = content
+            if "ERROR" in content.upper():
                 outcome = "failed/struggled"
                 
         conv_parts = []
         for m in messages:
-            if m.content:
-                conv_parts.append(f"{m.type}: {str(m.content)[:200]}...")
+            content = _content_to_text(m.content)
+            if content:
+                conv_parts.append(f"{m.type}: {content[:200]}...")
         conv_str = "\n".join(conv_parts)
 
         prompt = f"""
@@ -159,10 +188,10 @@ Briefly explain:
 Keep it under 150 words.
 """
         response = model.invoke(prompt)
-        _store.add_episode(initial_question, response.content, outcome)
+        _store.add_episode(initial_question, _content_to_text(response.content), outcome)
         log.info("[memory] Episode saved.")
-    except Exception as e:
-        log.error(f"[memory] Summarization failed: {e}")
+    except Exception:
+        log.exception("[memory] Summarization failed")
 
 def retrieve_relevant_context(query: str) -> str:
     """Fetches all facts and recent episodes to inject into the prompt."""
@@ -180,6 +209,6 @@ def retrieve_relevant_context(query: str) -> str:
             context_parts.append(f"<past_experiences>\n{epi_lines}\n</past_experiences>")
             
         return "\n\n".join(context_parts)
-    except Exception as e:
-        log.error(f"[memory] Retrieval failed: {e}")
+    except Exception:
+        log.exception("[memory] Retrieval failed")
         return ""

tests/test_memory_persistence.py

@@ -1,7 +1,9 @@
 import pytest
 from pathlib import Path
+import logging
 from lilith_agent.config import Config
 from lilith_agent.app import build_react_agent
+from langchain_core.messages import HumanMessage
 
 def test_build_react_agent_uses_sqlite_saver(tmp_path):
     cfg = Config.from_env()
@@ -18,3 +20,67 @@ def test_build_react_agent_uses_sqlite_saver(tmp_path):
     # Check if DB file was created
     db_path = tmp_path / ".lilith" / "threads.sqlite"
     assert db_path.exists()
+
+
+def test_summarize_episode_stores_list_block_content_as_text(tmp_path, monkeypatch):
+    from lilith_agent import memory
+
+    class FakeModel:
+        def invoke(self, prompt):
+            class Response:
+                content = [
+                    {"type": "text", "text": "Captured lesson"},
+                    {"type": "non_text", "value": "ignored"},
+                ]
+
+            return Response()
+
+    store = memory.MemoryStore(tmp_path / "long_term_memory.sqlite")
+    monkeypatch.setattr(memory, "_store", store)
+
+    memory.summarize_episode(
+        [HumanMessage(content=[{"type": "text", "text": "Remember this"}])],
+        FakeModel(),
+    )
+
+    episodes = store.get_recent_episodes()
+    assert episodes[0]["task"] == "Remember this"
+    assert episodes[0]["summary"] == "Captured lesson"
+
+
+def test_summarize_episode_logs_traceback_on_failure(tmp_path, monkeypatch, caplog):
+    from lilith_agent import memory
+
+    class BrokenModel:
+        def invoke(self, prompt):
+            raise RuntimeError("boom")
+
+    store = memory.MemoryStore(tmp_path / "long_term_memory.sqlite")
+    monkeypatch.setattr(memory, "_store", store)
+
+    with caplog.at_level(logging.ERROR, logger="lilith_agent.memory"):
+        memory.summarize_episode([HumanMessage(content="Remember this")], BrokenModel())
+
+    record = next(r for r in caplog.records if "Summarization failed" in r.message)
+    assert record.exc_info is not None
+
+
+def test_extract_and_compress_facts_passes_existing_memories_as_strings(tmp_path, monkeypatch):
+    from lilith_agent import memory
+    import langmem
+
+    captured = {}
+
+    class FakeManager:
+        def invoke(self, payload):
+            captured["existing"] = payload["existing"]
+            return []
+
+    store = memory.MemoryStore(tmp_path / "long_term_memory.sqlite")
+    store.save_memories([{"id": "memory-1", "content": "Existing fact"}])
+    monkeypatch.setattr(memory, "_store", store)
+    monkeypatch.setattr(langmem, "create_memory_manager", lambda model, enable_deletes: FakeManager())
+
+    memory.extract_and_compress_facts([HumanMessage(content="New fact")], object())
+
+    assert captured["existing"] == ["Existing fact"]