Parse wrapped Codex rollout records

app.py

@@ -246,11 +246,25 @@ def _collect_timestamps(obj: dict[str, Any], timestamps: list[datetime]) -> None
                 timestamps.append(parsed)
 
 
+def _payload_command(payload: dict[str, Any]) -> str:
+    name = str(payload.get("name") or "function_call")
+    arguments = payload.get("arguments")
+    if isinstance(arguments, dict):
+        command = arguments.get("command")
+        if command:
+            return str(command)
+        return f"{name}({json.dumps(arguments, ensure_ascii=True)})"
+    if arguments:
+        return f"{name}({arguments})"
+    return name
+
+
 @lru_cache(maxsize=6)
 def _load_session(file_name: str) -> dict[str, Any]:
     path = _download_session(file_name)
     events: list[dict[str, Any]] = []
     timestamps: list[datetime] = []
+    pending_commands: list[str] = []
     command_ids: set[str] = set()
     failed_commands = 0
     turn_completed = 0
@@ -276,10 +290,111 @@ def _load_session(file_name: str) -> dict[str, Any]:
                 continue
 
             obj_type = obj.get("type")
+            payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+            payload_type = payload.get("type")
             item = obj.get("item") if isinstance(obj.get("item"), dict) else {}
             item_type = item.get("type")
             _collect_timestamps(obj, timestamps)
 
+            if obj_type == "turn_context":
+                turn_started += 1
+                continue
+
+            if obj_type == "event_msg":
+                if payload_type in {"agent_message", "user_message"}:
+                    text = str(payload.get("message") or "")
+                    is_user = payload_type == "user_message"
+                    events.append(
+                        {
+                            "kind": "user" if is_user else "agent",
+                            "role": "USER" if is_user else "AGENT",
+                            "line": line_no,
+                            "id": f"line-{line_no}",
+                            "text": text,
+                            "search": text,
+                        }
+                    )
+                    continue
+
+                if payload_type == "token_count":
+                    turn_completed += 1
+                    usage = {key: int(payload.get(key) or 0) for key in usage_summary}
+                    for key, value in usage.items():
+                        usage_summary[key] += value
+                    events.append(
+                        {
+                            "kind": "usage",
+                            "line": line_no,
+                            "usage": usage,
+                            "search": " ".join(
+                                [
+                                    "turn completed usage tokens",
+                                    " ".join(f"{k} {v}" for k, v in usage.items()),
+                                ]
+                            ),
+                        }
+                    )
+                    continue
+
+                if payload_type == "item_completed" and payload.get("item_type") == "todo_list":
+                    todos = payload.get("todos") or payload.get("items") or []
+                    if isinstance(todos, list):
+                        text = " ".join(str(todo.get("text") or "") for todo in todos if isinstance(todo, dict))
+                        events.append(
+                            {
+                                "kind": "todo",
+                                "line": line_no,
+                                "id": f"line-{line_no}",
+                                "items": todos,
+                                "search": text,
+                            }
+                        )
+                    continue
+
+                if payload_type == "patch_apply_end":
+                    path_value = str(payload.get("path") or "patch")
+                    events.append(
+                        {
+                            "kind": "files",
+                            "line": line_no,
+                            "id": f"line-{line_no}",
+                            "changes": [{"kind": "patch", "path": path_value}],
+                            "status": payload.get("status") or "",
+                            "search": f"patch {path_value} {payload.get('status') or ''}",
+                        }
+                    )
+                    continue
+
+            if obj_type == "response_item":
+                if payload_type == "function_call":
+                    pending_commands.append(_payload_command(payload))
+                    continue
+
+                if payload_type == "function_call_output":
+                    command = pending_commands.pop(0) if pending_commands else "function_call_output"
+                    output = _strip_ansi(payload.get("output") or "")
+                    exit_code = payload.get("exit_code")
+                    status = "failed" if exit_code not in (None, 0) else "completed"
+                    label, status_class = _command_status({"status": status, "exit_code": exit_code})
+                    if status_class == "fail":
+                        failed_commands += 1
+                    item_id = f"line-{line_no}"
+                    command_ids.add(item_id)
+                    events.append(
+                        {
+                            "kind": "command",
+                            "line": line_no,
+                            "id": item_id,
+                            "command": command,
+                            "output": output,
+                            "exit_code": exit_code,
+                            "status": label,
+                            "status_class": status_class,
+                            "search": " ".join([command, output, str(exit_code), label]),
+                        }
+                    )
+                    continue
+
             if obj_type == "turn.started":
                 turn_started += 1
                 continue
@@ -447,10 +562,12 @@ def _render_summary(data: dict[str, Any], matches: int, query: str) -> str:
 
 def _render_agent(event: dict[str, Any]) -> str:
     text, note = _limit_text(str(event.get("text") or ""), MAX_MESSAGE_CHARS, "message")
+    role = str(event.get("role") or "AGENT").upper()
+    role_class = "user" if role == "USER" else "agent"
     return (
-        '<article class="event agent-event">'
-        '<div class="event-rail agent-rail">AGENT</div>'
-        '<div class="bubble agent-bubble">'
+        f'<article class="event {role_class}-event">'
+        f'<div class="event-rail {role_class}-rail">{_escape(role)}</div>'
+        f'<div class="bubble {role_class}-bubble">'
         f'<div class="event-meta">line {_fmt_number(event["line"])}{_escape(note)}</div>'
         f'<div class="message-text">{_escape(text)}</div>'
         "</div>"
@@ -555,7 +672,7 @@ def _render_files(event: dict[str, Any]) -> str:
 
 def _render_event(event: dict[str, Any]) -> str:
     kind = event.get("kind")
-    if kind == "agent":
+    if kind in {"agent", "user"}:
         return _render_agent(event)
     if kind == "command":
         return _render_command(event)
@@ -948,6 +1065,7 @@ html, body, .gradio-container {
 }
 
 .agent-rail { color: var(--ct-blue); }
+.user-rail { color: var(--ct-cyan); }
 .command-rail { color: var(--ct-yellow); }
 .usage-rail { color: var(--ct-green); }
 .todo-rail { color: var(--ct-cyan); }
@@ -970,6 +1088,12 @@ html, body, .gradio-container {
   border-left: 3px solid var(--ct-blue);
 }
 
+.user-bubble {
+  padding: 14px 15px;
+  border-left: 3px solid var(--ct-cyan);
+  background: #101820;
+}
+
 .event-meta {
   color: var(--ct-muted);
   font-family: var(--ct-mono);