Harden memory + anthropic adapter against None/missing-key crashes

memory.py: MemoryEntry.__post_init__ coerces None/non-str content to "".
content is read as a str in 8+ places (search, _score_entry, dedup, prompt
injection); a malformed entry with content=None (e.g. from a hand-edited
memory file or a runtime add_entry) crashed memory search, which runs on
every system-prompt build. BM25/IDF/avgdl math was already correctly guarded.

anthropic_adapter.py: replace direct self.runtime["model"] (x3),
["baseUrl"], and else-branch ["authToken"] with .get(...) defaults, matching
the openai_adapter fix — a runtime missing these keys no longer raises
KeyError (authToken missing → "Bearer " → clear 401 instead of crash).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: QUSETIONS

minicode/anthropic_adapter.py

@@ -181,7 +181,7 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
             self._thinking_blocks = []
 
         request_body = {
-            "model": self.runtime["model"],
+            "model": self.runtime.get("model", ""),
             "system": system_message,
             "messages": converted_messages,
             "tools": self._get_serialized_tools(),
@@ -196,15 +196,15 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
             request_body["stream"] = True
 
         request = urllib.request.Request(
-            url=_messages_endpoint(self.runtime["baseUrl"]),
+            url=_messages_endpoint(self.runtime.get("baseUrl", "")),
             data=json.dumps(request_body).encode("utf-8"),
             headers={
                 "content-type": "application/json",
                 "anthropic-version": "2023-06-01",
                 **(
                     {"x-api-key": self.runtime["apiKey"]}
                     if self.runtime.get("apiKey")
-                    else {"Authorization": f"Bearer {self.runtime['authToken']}"}
+                    else {"Authorization": f"Bearer {self.runtime.get('authToken', '')}"}
                 ),
             },
             method="POST",
@@ -262,7 +262,7 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
                 cache_creation_tokens = usage.get("cache_creation_input_tokens", 0)
 
                 cost_usd = calculate_cost(
-                    model=self.runtime["model"],
+                    model=self.runtime.get("model", ""),
                     input_tokens=input_tokens,
                     output_tokens=output_tokens,
                     cache_read_tokens=cache_read_tokens,
@@ -406,7 +406,7 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
         if store:
             from minicode.cost_tracker import calculate_cost
             cost_usd = calculate_cost(
-                model=self.runtime["model"],
+                model=self.runtime.get("model", ""),
                 input_tokens=stream_input_tokens,
                 output_tokens=stream_output_tokens,
                 cache_read_tokens=stream_cache_read_tokens,

minicode/memory.py

@@ -648,6 +648,14 @@ class MemoryEntry:
     related_to: list[str] = field(default_factory=list)  # Related memory IDs
     _cached_tokens: list[str] | None = field(default=None, repr=False)
 
+    def __post_init__(self) -> None:
+        # `content` is accessed as a str throughout search/scoring/formatting
+        # (8+ sites use .lower()/.strip()/[:N]); coerce None/non-str at
+        # construction so a malformed entry can't crash a memory search, which
+        # is injected into every system prompt.
+        if not isinstance(self.content, str):
+            self.content = "" if self.content is None else str(self.content)
+
     def __hash__(self) -> int:
         return hash(self.id)
 

tests/test_memory_integration.py

@@ -1180,3 +1180,26 @@ def test_memory_file_entry_limit(self, tmp_workspace):
             mm.add_entry(MemoryScope.PROJECT, "test", f"Entry {i}")
 
         assert len(mm.memories[MemoryScope.PROJECT].entries) <= max_entries
+
+
+# ---------------------------------------------------------------------------
+# Robustness: None / non-str content must not crash search (injected into prompts)
+# ---------------------------------------------------------------------------
+
+
+def test_memory_entry_coerces_none_content():
+    """MemoryEntry.content is accessed as str in 8+ places (.lower()/.strip());
+    construction must coerce None/non-str so a malformed entry can't crash a
+    memory search (which runs on every system-prompt build)."""
+    assert MemoryEntry(id="a", content=None, scope=MemoryScope.PROJECT, category="c").content == ""
+    assert MemoryEntry(id="b", content=123, scope=MemoryScope.PROJECT, category="c").content == "123"
+
+
+def test_search_survives_none_content_entry(tmp_path):
+    mgr = MemoryManager(project_root=tmp_path)
+    mf = mgr.memories[MemoryScope.PROJECT]
+    mf.entries.append(MemoryEntry(id="bad", content=None, scope=MemoryScope.PROJECT, category="c"))
+    mf.entries.append(MemoryEntry(id="good", content="how to run the test suite", scope=MemoryScope.PROJECT, category="convention"))
+    # Must not raise; the good entry is still searchable.
+    results = mgr.search("run the test suite")
+    assert any("test suite" in e.content for e in results)