fix: update litellm and stabilize review persistence

Author: voytas75

core/health.py

@@ -95,7 +95,7 @@ def _check_litellm() -> List[str]:
     except metadata.PackageNotFoundError:
         return []
 
-    expected = "1.61.15"
+    expected = "1.83.0"
     if installed != expected:
         return [
             f"litellm version {installed} detected; expected {expected}."

core/memory_manager.py

@@ -647,9 +647,10 @@ def get_semantic(self, node_id: str) -> Optional[Dict[str, object]]:
         return None
 
     def list_layer(self, layer: str) -> List[Dict[str, object]]:
-        """Return layer payloads from the available store."""
+        """Return layer payloads from the available store, ordered oldest to newest."""
         if self._collection is None:
-            return list(self._fallback[layer].values())
+            items = list(self._fallback[layer].values())
+            return self._sort_layer_payloads(layer, items)
 
         try:  # pragma: no cover - depends on chromadb
             query = self._collection.get(
@@ -661,10 +662,22 @@ def list_layer(self, layer: str) -> List[Dict[str, object]]:
             for doc in documents:
                 if isinstance(doc, str):
                     parsed.append(cast(Dict[str, object], json.loads(doc)))
-            return parsed
+            return self._sort_layer_payloads(layer, parsed)
         except Exception as exc:
             raise MemoryError(f"Failed to query {layer} memory: {exc}") from exc
 
+    @staticmethod
+    def _sort_layer_payloads(
+        layer: str,
+        items: Sequence[Dict[str, object]],
+    ) -> List[Dict[str, object]]:
+        """Return payloads in deterministic chronological order for each layer."""
+        timestamp_field = "timestamp" if layer in {"episodic", "semantic"} else "created_at"
+        return sorted(
+            items,
+            key=lambda item: RedisMemoryStore._coerce_timestamp(item.get(timestamp_field)),
+        )
+
     def query_layer(self, layer: str, query: str, limit: int) -> List[Dict[str, object]]:
         """Return layer entries relevant to *query*, preferring semantic search."""
         limit = max(1, limit)

requirements.txt

@@ -1,5 +1,5 @@
 chromadb==0.5.3
-litellm==1.61.15
+litellm==1.83.0
 pydantic==2.9.2
 python-dotenv==1.0.1
 PySide6==6.8.2

tests/test_chroma_integration.py

@@ -5,6 +5,8 @@
 import types
 from pathlib import Path
 
+import pytest
+
 from config.settings import load_app_config
 from core.memory_manager import MemoryManager
 from models.memory import SemanticNode
@@ -14,12 +16,24 @@ class _StubCollection:
     def __init__(self) -> None:
         self._store: dict[str, str] = {}
 
-    def upsert(self, ids=None, documents=None, metadatas=None, **_: object):  # pragma: no cover - stub
+    def upsert(
+        self,
+        ids: list[str] | None = None,
+        documents: list[str] | None = None,
+        metadatas: list[dict[str, object]] | None = None,
+        **_: object,
+    ) -> None:  # pragma: no cover - stub
         if not ids or not documents:
             return
         self._store[ids[0]] = documents[0]
 
-    def get(self, *, where=None, include=None, ids=None):  # pragma: no cover - stub
+    def get(
+        self,
+        *,
+        where: object = None,
+        include: object = None,
+        ids: list[str] | None = None,
+    ) -> dict[str, list[str]]:  # pragma: no cover - stub
         if ids:
             document = self._store.get(ids[0])
             return {"documents": [document] if document else []}
@@ -31,14 +45,21 @@ def __init__(self, path: str) -> None:  # pragma: no cover - simple stub
         self._path = path
         self._collection = _StubCollection()
 
-    def get_or_create_collection(self, name: str, embedding_function=None):
+    def get_or_create_collection(
+        self,
+        name: str,
+        embedding_function: object = None,
+    ) -> _StubCollection:
         return self._collection
 
-    def list_collections(self):  # pragma: no cover - stub
+    def list_collections(self) -> list[object]:  # pragma: no cover - stub
         return []
 
 
-def test_semantic_roundtrip_with_chroma_stub(monkeypatch, tmp_path: Path) -> None:
+def test_semantic_roundtrip_with_chroma_stub(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     chroma_stub = types.SimpleNamespace(PersistentClient=_StubClient)
 
     monkeypatch.setenv("DRM_MEMORY_LOG_PATH", str(tmp_path / "revisions.jsonl"))

tests/test_cli_smoke.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import logging
+from pathlib import Path
+
+import pytest
 
 from config.settings import load_app_config
 from core.user_settings import UserSettingsManager
@@ -14,11 +17,21 @@
 class _StubLoop:
     last_instance: "_StubLoop | None" = None
 
-    def __init__(self, _config, user_settings=None) -> None:  # pragma: no cover - simple stub
-        self.last_override = None
+    def __init__(
+        self,
+        _config: object,
+        user_settings: object = None,
+    ) -> None:  # pragma: no cover - simple stub
+        self.last_override: str | None = None
         type(self).last_instance = self
 
-    def run_task(self, *, task: str, workflow_override=None, human_feedback=None):
+    def run_task(
+        self,
+        *,
+        task: str,
+        workflow_override: str | None = None,
+        human_feedback: str | None = None,
+    ) -> TaskRunOutcome:
         assert task == "demo"
         assert human_feedback == "note"
         self.last_override = workflow_override
@@ -44,7 +57,10 @@ def run_task(self, *, task: str, workflow_override=None, human_feedback=None):
         )
 
 
-def test_run_cli_emits_feedback(monkeypatch, caplog) -> None:
+def test_run_cli_emits_feedback(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
     monkeypatch.setattr("main.LiveTaskLoop", _StubLoop)
     config = load_app_config()
 
@@ -56,7 +72,10 @@ def test_run_cli_emits_feedback(monkeypatch, caplog) -> None:
     assert "Mitigation actions" in caplog.text
 
 
-def test_run_cli_prefers_saved_workflow(monkeypatch, tmp_path) -> None:
+def test_run_cli_prefers_saved_workflow(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     monkeypatch.setattr("main.LiveTaskLoop", _StubLoop)
     config = load_app_config()
 

tests/test_controller.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from typing import cast
 from uuid import uuid4
 
 from config.settings import load_app_config
@@ -68,5 +69,7 @@ def test_controller_records_slo_breaches() -> None:
 
     plan = controller.last_plan
     assert plan
-    assert set(plan.get("slo_breaches", [])) == {"latency", "quality"}
-    assert "expand_context_retrieval" in plan.get("recommended_actions", [])
+    slo_breaches = cast(list[str], plan.get("slo_breaches", []))
+    recommended_actions = cast(list[str], plan.get("recommended_actions", []))
+    assert set(slo_breaches) == {"latency", "quality"}
+    assert "expand_context_retrieval" in recommended_actions

tests/test_health.py

@@ -35,13 +35,13 @@ def ping(self) -> bool:
 
     redis_module = types.SimpleNamespace(Redis=_RedisClient)
     chroma_module = _build_chroma_stub(tmp_path)
-    litellm_module = types.SimpleNamespace(__version__="1.61.15")
+    litellm_module = types.SimpleNamespace(__version__="1.83.0")
 
     monkeypatch.setitem(sys.modules, "redis", redis_module)
     monkeypatch.setitem(sys.modules, "chromadb", chroma_module)
     monkeypatch.setitem(sys.modules, "litellm", litellm_module)
 
-    monkeypatch.setattr("core.health.metadata.version", lambda _: "1.61.15")
+    monkeypatch.setattr("core.health.metadata.version", lambda _: "1.83.0")
 
 
 def _build_chroma_stub(tmp_path: Path) -> types.SimpleNamespace:
@@ -83,6 +83,7 @@ def test_health_checks_warn_on_redis_failure(monkeypatch: pytest.MonkeyPatch, tm
 def test_health_checks_warn_when_standard_embedding_missing(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     config = _load_config(tmp_path)
     config.memory.chromadb.persist_directory = str(tmp_path / "chroma")
+    assert config.embedding is not None
     config.embedding.model = "text-embedding-3-large"
 
     _install_stub_modules(monkeypatch, tmp_path)

tests/test_live_task_loop.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from pathlib import Path
+from typing import Any, Optional, cast
+
+import pytest
 
 from config.settings import load_app_config
 from core.controller import SelfAdjustingController
@@ -50,7 +53,10 @@ def perform_review(
         )
 
 
-def test_live_task_loop_persists_memory(monkeypatch, tmp_path) -> None:
+def test_live_task_loop_persists_memory(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     """Running the live loop should persist artefacts and log revisions."""
 
     monkeypatch.setenv("DRM_MEMORY_LOG_PATH", str(tmp_path / "revisions.jsonl"))
@@ -65,8 +71,8 @@ def test_live_task_loop_persists_memory(monkeypatch, tmp_path) -> None:
     loop = LiveTaskLoop(
         config,
         memory_manager=memory_manager,
-        executor=_StubExecutor(),
-        review_engine=_StubReviewEngine(),
+        executor=cast(Any, _StubExecutor()),
+        review_engine=cast(Any, _StubReviewEngine()),
         controller=controller,
     )
 

tests/test_memory_revisions.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import json
+from pathlib import Path
+
+import pytest
 
 from config.settings import load_app_config
 from core.memory_manager import MemoryManager
@@ -14,7 +17,10 @@
 )
 
 
-def test_memory_revision_log_records_changes(monkeypatch, tmp_path) -> None:
+def test_memory_revision_log_records_changes(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     """Ensure all memory layers append to the revision log."""
 
     monkeypatch.setenv("DRM_MEMORY_LOG_PATH", str(tmp_path / "revisions.jsonl"))
@@ -54,7 +60,10 @@ def test_memory_revision_log_records_changes(monkeypatch, tmp_path) -> None:
     assert (tmp_path / "revisions.jsonl").exists()
 
 
-def test_revision_log_verification_and_replay(monkeypatch, tmp_path) -> None:
+def test_revision_log_verification_and_replay(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     """Revision log should expose verification and replay helpers."""
 
     log_path = tmp_path / "revisions.jsonl"
@@ -102,7 +111,10 @@ def test_revision_log_verification_and_replay(monkeypatch, tmp_path) -> None:
     assert not manager.verify_revision_log()
 
 
-def test_query_layer_prefers_relevant_results(monkeypatch, tmp_path) -> None:
+def test_query_layer_prefers_relevant_results(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     """Querying episodic memory should surface the most relevant entries."""
 
     monkeypatch.setenv("DRM_MEMORY_LOG_PATH", str(tmp_path / "revisions.jsonl"))

tests/test_semantic_graph.py

@@ -2,14 +2,19 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 
 from config.settings import load_app_config
 from core.memory_manager import MemoryManager
 from models.memory import SemanticNode, WorkingMemoryItem
 
 
-def _bootstrap_manager(monkeypatch, tmp_path) -> MemoryManager:
+def _bootstrap_manager(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> MemoryManager:
     monkeypatch.setenv("DRM_MEMORY_LOG_PATH", str(tmp_path / "revisions.jsonl"))
     monkeypatch.setattr("core.memory_manager.redis_module", None)
     monkeypatch.setattr("core.memory_manager.chromadb_module", None)
@@ -18,7 +23,10 @@ def _bootstrap_manager(monkeypatch, tmp_path) -> MemoryManager:
     return MemoryManager(config)
 
 
-def test_link_semantic_nodes_updates_relations(monkeypatch, tmp_path) -> None:
+def test_link_semantic_nodes_updates_relations(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     manager = _bootstrap_manager(monkeypatch, tmp_path)
 
     node_a = SemanticNode(id="concept:a", label="Alpha", definition="Alpha concept")
@@ -37,7 +45,10 @@ def test_link_semantic_nodes_updates_relations(monkeypatch, tmp_path) -> None:
     assert forward[0][1] == pytest.approx(0.75, abs=1e-6)
 
 
-def test_list_semantic_nodes_returns_ordered(monkeypatch, tmp_path) -> None:
+def test_list_semantic_nodes_returns_ordered(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     manager = _bootstrap_manager(monkeypatch, tmp_path)
 
     first = SemanticNode(id="concept:old", label="Old", definition="Old concept")
@@ -53,7 +64,10 @@ def test_list_semantic_nodes_returns_ordered(monkeypatch, tmp_path) -> None:
     assert [node.id for node in limited] == [second.id]
 
 
-def test_apply_drift_mitigation_prunes_working(monkeypatch, tmp_path) -> None:
+def test_apply_drift_mitigation_prunes_working(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
     manager = _bootstrap_manager(monkeypatch, tmp_path)
 
     for index in range(3):