Function _assemble_conversation

uncommon_route/proxy.py:2556–2732

(
    traces: "TraceStore", session_id: str
)

def _assemble_conversation(
    traces: "TraceStore", session_id: str
) -> dict[str, Any] | None:
    # 1. Pull all hot rows for this session_id.
    matching = [r for r in traces._records if r.session_id == session_id]
    if not matching:
        return None
    matching.sort(key=lambda r: r.timestamp)

    # 2. Pull cold fields per turn.
    cold_by_id: dict[str, dict[str, Any]] = {}
    for t in matching:
        cold = traces.load_content(t.request_id)
        if cold is not None:
            cold_by_id[t.request_id] = cold

    has_any_content = any(
        (c.get("request_messages") or c.get("response_text"))
        for c in cold_by_id.values()
    )

    # 3. Compact-break detection from msg_hashes.
    breaks: list[int] = []
    for k in range(1, len(matching)):
        prev = list(matching[k - 1].msg_hashes or [])
        curr = list(matching[k].msg_hashes or [])
        if not prev or not curr:
            continue
        if curr[: len(prev)] != prev:
            breaks.append(k)

    if not has_any_content:
        # Surface turn-level decisions only (no message bodies).
        decisions = [
            {
                "role": "assistant",
                "text": "",
                "tool_calls": [],
                "ts": t.timestamp,
                "request_id": t.request_id,
                "decision": _trace_decision_card(t),
            }
            for t in matching
        ]
        return {
            "session_id": session_id,
            "turn_count": len(matching),
            "content_available": False,
            "compact_breaks": breaks,
            "messages": decisions,
        }

    # 4. Build backbone from the LAST turn's request_messages.
    last_turn = matching[-1]
    last_cold = cold_by_id.get(last_turn.request_id, {})
    backbone = list(last_cold.get("request_messages") or [])

    # 5. Walk backbone, expand into chat messages with decisions.