fix(llm): normalize SDK content blocks + route through db.local_today

Two issues from the new Copilot review pass.

1) chat() was appending response.content (real Anthropic SDK pydantic
   blocks) verbatim to messages on tool_use iterations. The SDK *does*
   accept its own block types on input, but normalizing to plain dicts
   is more robust across SDK versions and makes the wire format
   deterministic. New _block_to_dict helper:
   - dicts pass through unchanged
   - SDK objects use .model_dump() with try/except fallback
   - SimpleNamespace / arbitrary attrs fall back to manual extraction
     for tool_use / text shapes
   The chat loop now serializes content via [_block_to_dict(b) for b
   in response.content] before re-posting.

2) Promoted db._local_today → db.local_today (single underscore-free
   public name) and routed _execute_chat_tool's two day-bucket lookups
   through it. Now the patch hook used by the test_nutrition.py
   regression cases (test_recent_calorie_balance_anchors_on_local_today,
   etc.) covers the chat tool dispatcher too — one patchable seam for
   all "what local day is it?" computations across db.py and llm.py.

Tests (+4)
- test_chat_normalizes_content_blocks_to_dicts_before_re_sending:
  asserts the assistant turn that goes back to messages.create has
  plain dicts (not SimpleNamespace / SDK objects) and the round-trip
  preserves type/id/name/input.
- test_block_to_dict_uses_model_dump_when_available: real-SDK path.
- test_block_to_dict_falls_back_when_model_dump_raises: defensive path.
- test_execute_chat_tool_uses_db_local_today: patches db.local_today
  to a fixed date and confirms get_balance resolves "today" through it.

Tests adjusted (rename _local_today → local_today across):
- src/db.py (definition + 4 callsites)
- tests/test_nutrition.py (4 patches + sanity test)
- tests/test_training_intel.py (1 doc reference)

Test count: 144 → 148.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: fdsimoes-git

src/db.py

@@ -73,7 +73,7 @@
 """
 
 
-def _local_today() -> date:
+def local_today() -> date:
     """The Pi's local 'today'.
 
     The codebase has a deliberate split: timestamps are stored in UTC (they
@@ -181,7 +181,7 @@ def recent_activities(db_path: Path, days: int = 7) -> list[dict]:
     """Return activities with `date` within the last `days` days, newest first."""
     # `activities.date` is local-formatted (Garmin's startTimeLocal[:10]),
     # so the cutoff must be Pi-local — not UTC.
-    cutoff = (_local_today() - timedelta(days=days)).isoformat()
+    cutoff = (local_today() - timedelta(days=days)).isoformat()
     with connect(db_path) as conn:
         conn.row_factory = sqlite3.Row
         rows = conn.execute(
@@ -439,7 +439,7 @@ def prune_old_data(con: sqlite3.Connection, days: int = 90) -> dict[str, int]:
     # `meal_time` is stored as a UTC ISO timestamp → cutoff must be UTC.
     # `activities.date` is local-formatted → cutoff must be Pi-local.
     cutoff_ts = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat(timespec="seconds")
-    cutoff_date = (_local_today() - timedelta(days=days)).isoformat()
+    cutoff_date = (local_today() - timedelta(days=days)).isoformat()
     deleted: dict[str, int] = {}
     cur = con.execute("DELETE FROM activities WHERE date < ?", (cutoff_date,))
     deleted["activities"] = cur.rowcount or 0
@@ -573,9 +573,9 @@ def recent_calorie_balance(db_path: Path, days: int, cfg) -> list[dict]:
 
     Pulls the per-day balance via `calorie_balance_for_date` so the math stays
     consistent with the CLI / dashboard output. Anchored on Pi-local "today"
-    to match the rest of the codebase (see `_local_today`).
+    to match the rest of the codebase (see `local_today`).
     """
-    today = _local_today()
+    today = local_today()
     out: list[dict] = []
     for offset in range(days - 1, -1, -1):
         d = (today - timedelta(days=offset)).isoformat()
@@ -687,9 +687,9 @@ def daily_readiness_history(db_path: Path, days: int, cfg) -> list[dict]:
 
     Skips days where the score is None (no data) — caller renders empty cells.
     Anchored on Pi-local "today" so the heatmap's most recent cell stays
-    aligned with what the user calls "today" (see `_local_today`).
+    aligned with what the user calls "today" (see `local_today`).
     """
-    today = _local_today()
+    today = local_today()
     out: list[dict] = []
     for offset in range(days - 1, -1, -1):
         d = (today - timedelta(days=offset)).isoformat()

src/llm.py

@@ -231,6 +231,38 @@ def _block_input(block) -> dict:
     return dict((block or {}).get("input") or {})
 
 
+def _block_to_dict(block) -> dict:
+    """Normalize a content block (SDK pydantic, plain dict, or test
+    SimpleNamespace) to a JSON-serializable dict suitable for sending back to
+    the API on the next loop iteration. The Anthropic SDK *does* accept its
+    own block objects on input, but normalizing keeps the wire format stable
+    and avoids any reliance on SDK serializer internals.
+    """
+    if isinstance(block, dict):
+        return dict(block)
+    # Real SDK objects expose `model_dump`.
+    if hasattr(block, "model_dump"):
+        try:
+            return block.model_dump()
+        except Exception:  # noqa: BLE001 — fall through to manual extraction
+            pass
+    # Manual fallback (covers SimpleNamespace and any future block shape).
+    btype = getattr(block, "type", None)
+    if btype == "tool_use":
+        return {
+            "type": "tool_use",
+            "id": getattr(block, "id", None),
+            "name": getattr(block, "name", None),
+            "input": getattr(block, "input", {}) or {},
+        }
+    if btype == "text":
+        return {"type": "text", "text": getattr(block, "text", "")}
+    # Last-resort: copy public attrs into a dict.
+    return {"type": btype, **{
+        k: v for k, v in vars(block).items() if not k.startswith("_")
+    }}
+
+
 def extract_meal_from_text(cfg: Config, user_text: str) -> dict | None:
     """Run a meal description through Claude and return the structured meal dict.
 
@@ -553,7 +585,11 @@ def _execute_chat_tool(
     """
     if pending is None:
         pending = {}
-    today = date.today().isoformat()
+    # Route every "what local day is it?" lookup through `db.local_today` so
+    # the chat tools share the codebase-wide patchable seam (mocked in the
+    # _local_today regression tests in test_nutrition.py).
+    today_d = db.local_today()
+    today = today_d.isoformat()
     target = (input_data.get("date") or today)
 
     # ── Read tools ────────────────────────────────────────────────────────
@@ -564,7 +600,6 @@ def _execute_chat_tool(
     if name == "get_recent_meals":
         days = max(1, min(int(input_data.get("days") or 7), 30))
         out: list[dict] = []
-        today_d = date.today()
         for offset in range(days - 1, -1, -1):
             d_iso = (today_d - timedelta(days=offset)).isoformat()
             out.extend(db.meals_for_date(cfg.db_path, d_iso))
@@ -783,7 +818,14 @@ def chat(
         )
 
         if getattr(response, "stop_reason", None) == "tool_use":
-            messages.append({"role": "assistant", "content": list(response.content)})
+            # Normalize SDK content blocks to plain dicts before re-sending.
+            # The SDK accepts its own pydantic blocks on input, but plain
+            # dicts are more robust across SDK versions and let our test
+            # fixtures (SimpleNamespace) round-trip through the same path.
+            messages.append({
+                "role": "assistant",
+                "content": [_block_to_dict(b) for b in response.content],
+            })
             tool_results: list[dict] = []
             for block in response.content:
                 btype = getattr(block, "type", None) or (

tests/test_llm.py

@@ -624,6 +624,73 @@ def test_chat_with_history_and_image_sends_image_only_for_current_turn():
     assert any(c.get("type") == "image" for c in sent[-1]["content"])
 
 
+def test_chat_normalizes_content_blocks_to_dicts_before_re_sending():
+    """The assistant turn appended to messages must contain plain dicts, not
+    SDK objects — protects against pydantic-vs-dict serializer mismatches on
+    the second loop iteration."""
+    cfg = _make_cfg(anthropic_api_key="sk-ant-api03-x")
+    tool_use_resp = SimpleNamespace(
+        content=[_tool_use_block("tu_1", "get_balance", {})],
+        stop_reason="tool_use",
+    )
+    final_resp = SimpleNamespace(
+        content=[_text_block("done")], stop_reason="end_turn",
+    )
+    fake_client = MagicMock()
+    fake_client.messages.create.side_effect = [tool_use_resp, final_resp]
+    with patch("src.llm.build_anthropic_client", return_value=fake_client), \
+         patch("src.llm.db.calorie_balance_for_date", return_value={"balance_kcal": 0}):
+        llm.chat(cfg, "x", {})
+    # Second call's messages should include the assistant turn with content
+    # as a list of plain dicts (not SimpleNamespace / SDK objects).
+    second = fake_client.messages.create.call_args_list[1].kwargs["messages"]
+    assistant_turn = next(m for m in second if m["role"] == "assistant")
+    for block in assistant_turn["content"]:
+        assert isinstance(block, dict), f"block is {type(block)}, expected dict"
+        assert "type" in block
+    # And it round-trips losslessly: still a tool_use with the same id+name+input.
+    tool_block = assistant_turn["content"][0]
+    assert tool_block["type"] == "tool_use"
+    assert tool_block["id"] == "tu_1"
+    assert tool_block["name"] == "get_balance"
+
+
+def test_block_to_dict_uses_model_dump_when_available():
+    """Real SDK blocks expose .model_dump(); use that path."""
+    class FakeSDKBlock:
+        def model_dump(self):
+            return {"type": "tool_use", "id": "tu_x", "name": "y", "input": {"a": 1}}
+
+    out = llm._block_to_dict(FakeSDKBlock())
+    assert out == {"type": "tool_use", "id": "tu_x", "name": "y", "input": {"a": 1}}
+
+
+def test_block_to_dict_falls_back_when_model_dump_raises():
+    """If model_dump raises (corrupt SDK state), the manual SimpleNamespace
+    fallback still produces a usable dict."""
+    class BrokenSDKBlock:
+        type = "text"
+        text = "hello"
+        def model_dump(self):
+            raise RuntimeError("boom")
+
+    out = llm._block_to_dict(BrokenSDKBlock())
+    assert out["type"] == "text"
+    assert out["text"] == "hello"
+
+
+def test_execute_chat_tool_uses_db_local_today(tmpdb_cfg):
+    """The dispatcher must route every 'what local day is it?' lookup through
+    db.local_today so day-bucketing is patchable in one place."""
+    from datetime import date as _date
+    fake_today = _date(2026, 5, 5)
+    with patch("src.llm.db.local_today", return_value=fake_today) as mock_local:
+        # get_balance with no date input → should resolve to local_today's ISO.
+        out = llm._execute_chat_tool("get_balance", {}, tmpdb_cfg, {})
+    assert mock_local.called
+    assert out["date"] == "2026-05-05"
+
+
 def test_chat_invokes_progress_cb_once_per_tool_use_block():
     """The progress callback fires before each tool's dispatcher runs and is
     given the tool name + input dict — never the SDK block itself."""

tests/test_nutrition.py

@@ -153,7 +153,7 @@ def test_meal_timing_summary_computes_window_and_count(tmpdb):
 
 def test_recent_calorie_balance_returns_one_row_per_day(tmpdb):
     cfg = _make_cfg(tmpdb)
-    # Production anchors on Pi-local 'today' (db._local_today). Match here
+    # Production anchors on Pi-local 'today' (db.local_today). Match here
     # so this test isn't UTC-flaky around midnight.
     today = date.today()
     db.insert_meal(tmpdb, {"description": "today's lunch", "source": "manual", "kcal": 600.0})
@@ -221,32 +221,32 @@ def test_delete_meal_returns_false_for_missing(tmpdb):
     assert db.delete_meal(tmpdb, 99999) is False
 
 
-def test_local_today_helper_returns_local_date():
-    """Sanity: _local_today() agrees with date.today() right now."""
-    assert db._local_today() == date.today()
+def testlocal_today_helper_returns_local_date():
+    """Sanity: local_today() agrees with date.today() right now."""
+    assert db.local_today() == date.today()
 
 
-def test_recent_calorie_balance_anchors_on_local_today(tmpdb):
+def test_recent_calorie_balance_anchors_onlocal_today(tmpdb):
     """Last entry in the 7-day balance series must be local today, not UTC."""
     from unittest.mock import patch
     cfg = _make_cfg(tmpdb)
     fake_today = date(2026, 5, 5)  # local
-    with patch("src.db._local_today", return_value=fake_today):
+    with patch("src.db.local_today", return_value=fake_today):
         out = db.recent_calorie_balance(tmpdb, days=7, cfg=cfg)
     assert out[-1]["date"] == "2026-05-05"
     assert out[0]["date"] == "2026-04-29"
 
 
-def test_daily_readiness_history_anchors_on_local_today(tmpdb):
+def test_daily_readiness_history_anchors_onlocal_today(tmpdb):
     from unittest.mock import patch
     cfg = _make_cfg(tmpdb)
     fake_today = date(2026, 5, 5)
-    with patch("src.db._local_today", return_value=fake_today):
+    with patch("src.db.local_today", return_value=fake_today):
         out = db.daily_readiness_history(tmpdb, days=3, cfg=cfg)
     assert [r["date"] for r in out] == ["2026-05-03", "2026-05-04", "2026-05-05"]
 
 
-def test_recent_activities_cutoff_uses_local_today(tmpdb):
+def test_recent_activities_cutoff_useslocal_today(tmpdb):
     """An activity dated as Pi-local 2026-05-05 must be findable when
     queried at local 2026-05-05, even when UTC has rolled over to 05-06."""
     from unittest.mock import patch
@@ -255,7 +255,7 @@ def test_recent_activities_cutoff_uses_local_today(tmpdb):
         "name": "easy run", "duration_s": 1800, "distance_m": 4000,
         "avg_hr": 130, "max_hr": 150, "calories": 300, "training_effect": 2.5,
     })
-    with patch("src.db._local_today", return_value=date(2026, 5, 5)):
+    with patch("src.db.local_today", return_value=date(2026, 5, 5)):
         out = db.recent_activities(tmpdb, days=1)
     assert any(a["activity_id"] == "a1" for a in out)
 

tests/test_training_intel.py

@@ -268,7 +268,7 @@ def test_daily_readiness_history_returns_one_per_day(tmpdb):
     cfg = _make_cfg(tmpdb)
     out = db.daily_readiness_history(tmpdb, days=7, cfg=cfg)
     assert len(out) == 7
-    # Production now anchors on Pi-local 'today' (db._local_today), so this
+    # Production now anchors on Pi-local 'today' (db.local_today), so this
     # plain `date.today()` matches and is no longer UTC-flaky.
     today = date.today().isoformat()
     assert out[-1]["date"] == today