fix(trace): serialize rollup turns to handler schema

Map trace response objects to RollupTurnInput so SDK rollup calls match the gateway contract.

Author: Latence AI

src/latence/resources/trace.py

@@ -94,16 +94,55 @@ def _normalize_session_state(
 def _normalize_turns(
     turns: list[TraceResponse | dict[str, Any]],
 ) -> list[dict[str, Any]]:
-    """Coerce a list of scoring responses / dicts to the rollup turn shape."""
+    """Coerce a list of scoring responses / dicts to the rollup turn shape.
+
+    The rollup handler expects ``RollupTurnInput`` with fields
+    ``scores``, ``risk_band``, ``file_attribution``, ``session_signals``,
+    ``recommendation``, ``timestamp`` — NOT the flat ``TraceResponse``
+    fields like ``score`` / ``band`` / ``success``.
+    """
     out: list[dict[str, Any]] = []
     for turn in turns:
         if isinstance(turn, TraceResponse):
-            out.append(turn.model_dump(exclude_none=True))
+            d = turn.model_dump(exclude_none=True)
+            out.append(_trace_response_to_rollup_turn(d))
+        elif isinstance(turn, dict):
+            if "scores" in turn or "risk_band" in turn:
+                out.append(turn)
+            else:
+                out.append(_trace_response_to_rollup_turn(turn))
         else:
             out.append(turn)
     return out
 
 
+def _trace_response_to_rollup_turn(d: dict[str, Any]) -> dict[str, Any]:
+    """Map flat TraceResponse dict to the RollupTurnInput shape."""
+    turn: dict[str, Any] = {}
+
+    scores: dict[str, float | None] = {}
+    if "score" in d and d["score"] is not None:
+        metric = d.get("primary_metric", "groundedness_v2")
+        scores[metric] = d["score"]
+    if "context_coverage_ratio" in d:
+        scores["context_coverage_ratio"] = d["context_coverage_ratio"]
+    if "context_usage_ratio" in d:
+        scores["context_usage_ratio"] = d["context_usage_ratio"]
+    if "nli_aggregate" in d:
+        scores["nli_aggregate"] = d["nli_aggregate"]
+    if scores:
+        turn["scores"] = scores
+
+    if "band" in d:
+        turn["risk_band"] = d["band"]
+
+    for passthrough in ("file_attribution", "session_signals", "recommendation", "timestamp"):
+        if passthrough in d and d[passthrough] is not None:
+            turn[passthrough] = d[passthrough]
+
+    return turn
+
+
 def _require_premise_lane(
     *,
     raw_context: str | None,

tests/test_trace.py

@@ -554,8 +554,15 @@ def test_rollup_accepts_response_objects(self):
         assert isinstance(body["turns"], list)
         assert len(body["turns"]) == 2
         assert all(isinstance(t, dict) for t in body["turns"])
-        # Code-lane-specific fields propagate.
-        assert body["turns"][0].get("code_lane") is not None
+        # Response objects are mapped to the handler's RollupTurnInput shape,
+        # not passed through with fields the gateway rejects.
+        assert body["turns"][0].get("scores") is not None
+        assert body["turns"][0].get("risk_band") == turn1.band
+        assert body["turns"][0].get("session_signals") is not None
+        assert "code_lane" not in body["turns"][0]
+        assert body["turns"][1].get("scores") is not None
+        assert body["turns"][1].get("risk_band") == turn2.band
+        assert "success" not in body["turns"][1]
         assert body["session_id"] == "sess_abc"
 
     def test_rollup_default_heatmap_not_sent(self):