glaip-sdk 0.0.5b1__py3-none-any.whl → 0.0.7__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -24,7 +24,7 @@ from glaip_sdk.utils.rendering.formatting import (
     get_spinner_char,
     is_step_finished,
 )
-from glaip_sdk.utils.rendering.models import RunStats
+from glaip_sdk.utils.rendering.models import RunStats, Step
 from glaip_sdk.utils.rendering.renderer.config import RendererConfig
 from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
 from glaip_sdk.utils.rendering.renderer.panels import (
@@ -56,7 +56,7 @@ class RendererState:
     printed_final_panel: bool = False
     finalizing_ui: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.buffer is None:
             self.buffer = []
 
@@ -66,11 +66,11 @@ class RichStreamRenderer:
 
     def __init__(
         self,
-        console=None,
+        console: RichConsole | None = None,
         *,
         cfg: RendererConfig | None = None,
         verbose: bool = False,
-    ):
+    ) -> None:
         """Initialize the renderer.
 
         Args:
@@ -107,7 +107,10 @@ class RichStreamRenderer:
         # Track per-step server start times for accurate elapsed labels
         self._step_server_start_times: dict[str, float] = {}
 
-    def on_start(self, meta: dict[str, Any]):
+        # Output formatting constants
+        self.OUTPUT_PREFIX: str = "**Output:**\n"
+
+    def on_start(self, meta: dict[str, Any]) -> None:
         """Handle renderer start event."""
         if self.cfg.live:
             # Defer creating Live to _ensure_live so tests and prod both work
@@ -118,40 +121,68 @@ class RichStreamRenderer:
         self.stream_processor.streaming_started_at = self._started_at
 
         # Print compact header and user request (parity with old renderer)
+        self._render_header(meta)
+        self._render_user_query(meta)
+
+    def _render_header(self, meta: dict[str, Any]) -> None:
+        """Render the agent header with metadata."""
+        parts = self._build_header_parts(meta)
+        self.header_text = " ".join(parts)
+
+        if not self.header_text:
+            return
+
+        # Use a rule-like header for readability with fallback
+        if not self._render_header_rule():
+            self._render_header_fallback()
+
+    def _build_header_parts(self, meta: dict[str, Any]) -> list[str]:
+        """Build header text parts from metadata."""
+        parts: list[str] = ["🤖"]
+        agent_name = meta.get("agent_name", "agent")
+        if agent_name:
+            parts.append(agent_name)
+
+        model = meta.get("model", "")
+        if model:
+            parts.extend(["•", model])
+
+        run_id = meta.get("run_id", "")
+        if run_id:
+            parts.extend(["•", run_id])
+
+        return parts
+
+    def _render_header_rule(self) -> bool:
+        """Render header as a rule. Returns True if successful."""
         try:
-            parts: list[str] = ["🤖"]
-            agent_name = meta.get("agent_name", "agent")
-            if agent_name:
-                parts.append(agent_name)
-            model = meta.get("model", "")
-            if model:
-                parts.extend(["•", model])
-            run_id = meta.get("run_id", "")
-            if run_id:
-                parts.extend(["•", run_id])
-            self.header_text = " ".join(parts)
-            if self.header_text:
-                try:
-                    # Use a rule-like header for readability
-                    self.console.rule(self.header_text)
-                except Exception:
-                    self.console.print(self.header_text)
+            self.console.rule(self.header_text)
+            return True
+        except Exception:  # pragma: no cover - defensive fallback
+            logger.exception("Failed to render header rule")
+            return False
+
+    def _render_header_fallback(self) -> None:
+        """Fallback header rendering."""
+        try:
+            self.console.print(self.header_text)
+        except Exception:
+            logger.exception("Failed to print header fallback")
+
+    def _render_user_query(self, meta: dict[str, Any]) -> None:
+        """Render the user query panel."""
+        query = meta.get("input_message") or meta.get("query") or meta.get("message")
+        if not query:
+            return
 
-            query = (
-                meta.get("input_message") or meta.get("query") or meta.get("message")
+        self.console.print(
+            AIPPanel(
+                Markdown(f"**Query:** {query}"),
+                title="User Request",
+                border_style="yellow",
+                padding=(0, 1),
             )
-            if query:
-                self.console.print(
-                    AIPPanel(
-                        Markdown(f"**Query:** {query}"),
-                        title="User Request",
-                        border_style="yellow",
-                        padding=(0, 1),
-                    )
-                )
-        except Exception:
-            # Non-fatal: header is nice-to-have
-            pass
+        )
 
     def on_event(self, ev: dict[str, Any]) -> None:
         """Handle streaming events from the backend."""
@@ -209,9 +240,12 @@ class RichStreamRenderer:
             # Note: Thinking gaps are primarily a visual aid. Keep minimal here.
 
             # Extract tool information
-            tool_name, tool_args, tool_out, tool_calls_info = (
-                self.stream_processor.parse_tool_calls(ev)
-            )
+            (
+                tool_name,
+                tool_args,
+                tool_out,
+                tool_calls_info,
+            ) = self.stream_processor.parse_tool_calls(ev)
 
             # Track tools and sub-agents
             self.stream_processor.track_tools_and_agents(
@@ -224,48 +258,57 @@ class RichStreamRenderer:
         # Update live display
         self._ensure_live()
 
-    def on_complete(self, _stats: RunStats):
+    def _finish_running_steps(self) -> None:
+        """Mark any running steps as finished to avoid lingering spinners."""
+        for st in list(self.steps.by_id.values()):
+            if not is_step_finished(st):
+                st.finish(None)
+
+    def _finish_tool_panels(self) -> None:
+        """Mark unfinished tool panels as finished."""
+        try:
+            items = list(self.tool_panels.items())
+        except Exception:  # pragma: no cover - defensive guard
+            logger.exception("Failed to iterate tool panels during cleanup")
+            return
+
+        for _sid, meta in items:
+            if meta.get("status") != "finished":
+                meta["status"] = "finished"
+
+    def _stop_live_display(self) -> None:
+        """Stop live display and clean up."""
+        self._shutdown_live()
+
+    def _print_final_panel_if_needed(self) -> None:
+        """Print final result panel if verbose mode and content available."""
+        if self.verbose and not self.state.printed_final_panel:
+            body = ("".join(self.state.buffer) or "").strip()
+            if body:
+                final_panel = create_final_panel(body, theme=self.cfg.theme)
+                self.console.print(final_panel)
+                self.state.printed_final_panel = True
+
+    def on_complete(self, _stats: RunStats) -> None:
         """Handle completion event."""
         self.state.finalizing_ui = True
 
         # Mark any running steps as finished to avoid lingering spinners
-        try:
-            for st in list(self.steps.by_id.values()):
-                if not is_step_finished(st):
-                    st.finish(None)
-        except Exception:
-            pass
+        self._finish_running_steps()
 
         # Mark unfinished tool panels as finished
-        try:
-            for _sid, meta in list(self.tool_panels.items()):
-                if meta.get("status") != "finished":
-                    meta["status"] = "finished"
-        except Exception:
-            pass
+        self._finish_tool_panels()
 
         # Final refresh
         self._ensure_live()
 
         # Stop live display
-        if self.live:
-            self.live.stop()
-            self.live = None
+        self._stop_live_display()
 
-        # If no explicit final_response was printed, but we have buffered content,
-        # print a final result panel so users still see the outcome (especially in --verbose).
-        try:
-            if self.verbose and not self.state.printed_final_panel:
-                body = ("".join(self.state.buffer) or "").strip()
-                if body:
-                    final_panel = create_final_panel(body, theme=self.cfg.theme)
-                    self.console.print(final_panel)
-                    self.state.printed_final_panel = True
-        except Exception:
-            # Non-fatal; renderer best-effort
-            pass
+        # Print final panel if needed
+        self._print_final_panel_if_needed()
 
-    def _ensure_live(self):
+    def _ensure_live(self) -> None:
         """Ensure live display is updated."""
         # Lazily create Live if needed
         if self.live is None and self.cfg.live:
@@ -292,14 +335,16 @@ class RichStreamRenderer:
             panels.extend(self._render_tool_panels())
             self.live.update(Group(*panels))
 
-    def _render_main_panel(self):
+    def _render_main_panel(self) -> Any:
         """Render the main content panel."""
         body = "".join(self.state.buffer).strip()
         # Dynamic title with spinner + elapsed/hints
         title = self._format_enhanced_main_title()
         return create_main_panel(body, title, self.cfg.theme)
 
-    def _maybe_insert_thinking_gap(self, task_id: str | None, context_id: str | None):
+    def _maybe_insert_thinking_gap(
+        self, task_id: str | None, context_id: str | None
+    ) -> None:
         """Insert thinking gap if needed."""
         # Implementation would track thinking states
         pass
@@ -345,7 +390,7 @@ class RichStreamRenderer:
         tool_name: str,
         tool_args: Any,
         _tool_sid: str,
-    ):
+    ) -> Step | None:
         """Start or get a step for a tool."""
         if is_delegation_tool(tool_name):
             st = self.steps.start_or_get(
@@ -373,8 +418,12 @@ class RichStreamRenderer:
         return st
 
     def _process_additional_tool_calls(
-        self, tool_calls_info: list, tool_name: str, task_id: str, context_id: str
-    ):
+        self,
+        tool_calls_info: list[tuple[str, Any, Any]],
+        tool_name: str,
+        task_id: str,
+        context_id: str,
+    ) -> None:
         """Process additional tool calls to avoid duplicates."""
         for call_name, call_args, _ in tool_calls_info or []:
             if call_name and call_name != tool_name:
@@ -421,55 +470,122 @@ class RichStreamRenderer:
 
         return False, None, None
 
+    def _get_tool_session_id(
+        self, finished_tool_name: str, task_id: str, context_id: str
+    ) -> str:
+        """Generate tool session ID."""
+        return f"tool_{finished_tool_name}_{task_id}_{context_id}"
+
+    def _calculate_tool_duration(self, meta: dict[str, Any]) -> float | None:
+        """Calculate tool duration from metadata."""
+        server_now = self.stream_processor.server_elapsed_time
+        server_start = meta.get("server_started_at")
+        dur = None
+
+        try:
+            if isinstance(server_now, (int, float)) and server_start is not None:
+                dur = max(0.0, float(server_now) - float(server_start))
+            else:
+                started_at = meta.get("started_at")
+                if started_at is not None:
+                    started_at_float = float(started_at)
+                    dur = max(0.0, float(monotonic()) - started_at_float)
+        except (TypeError, ValueError):
+            logger.exception("Failed to calculate tool duration")
+            return None
+
+        return dur
+
+    def _update_tool_metadata(self, meta: dict[str, Any], dur: float | None) -> None:
+        """Update tool metadata with duration information."""
+        if dur is not None:
+            meta["duration_seconds"] = dur
+            meta["server_finished_at"] = (
+                self.stream_processor.server_elapsed_time
+                if isinstance(self.stream_processor.server_elapsed_time, int | float)
+                else None
+            )
+            meta["finished_at"] = monotonic()
+
+    def _add_tool_output_to_panel(
+        self, meta: dict[str, Any], finished_tool_output: Any, finished_tool_name: str
+    ) -> None:
+        """Add tool output to panel metadata."""
+        if finished_tool_output is not None:
+            meta["chunks"].append(
+                self._format_output_block(finished_tool_output, finished_tool_name)
+            )
+            meta["output"] = finished_tool_output
+
+    def _mark_panel_as_finished(self, meta: dict[str, Any], tool_sid: str) -> None:
+        """Mark panel as finished and ensure visibility."""
+        if meta.get("status") != "finished":
+            meta["status"] = "finished"
+
+            dur = self._calculate_tool_duration(meta)
+            self._update_tool_metadata(meta, dur)
+
+        # Ensure this finished panel is visible in this frame
+        self.stream_processor.current_event_finished_panels.add(tool_sid)
+
     def _finish_tool_panel(
         self,
         finished_tool_name: str,
         finished_tool_output: Any,
         task_id: str,
         context_id: str,
-    ):
+    ) -> None:
         """Finish a tool panel and update its status."""
-        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-        if tool_sid in self.tool_panels:
-            meta = self.tool_panels[tool_sid]
-            prev_status = meta.get("status")
+        tool_sid = self._get_tool_session_id(finished_tool_name, task_id, context_id)
+        if tool_sid not in self.tool_panels:
+            return
 
-            if prev_status != "finished":
-                meta["status"] = "finished"
+        meta = self.tool_panels[tool_sid]
+        self._mark_panel_as_finished(meta, tool_sid)
+        self._add_tool_output_to_panel(meta, finished_tool_output, finished_tool_name)
 
-                # Compute and store duration
-                try:
-                    server_now = self.stream_processor.server_elapsed_time
-                    server_start = meta.get("server_started_at")
-                    dur = None
-
-                    if isinstance(server_now, int | float) and isinstance(
-                        server_start, int | float
-                    ):
-                        dur = max(0.0, float(server_now) - float(server_start))
-                    elif meta.get("started_at") is not None:
-                        dur = max(0.0, float(monotonic() - meta.get("started_at")))
-
-                    if dur is not None:
-                        meta["duration_seconds"] = dur
-                        meta["server_finished_at"] = (
-                            server_now if isinstance(server_now, int | float) else None
-                        )
-                        meta["finished_at"] = monotonic()
-                except Exception:
-                    pass
-
-                # Add output to panel
-                if finished_tool_output is not None:
-                    meta["chunks"].append(
-                        self._format_output_block(
-                            finished_tool_output, finished_tool_name
-                        )
-                    )
-                    meta["output"] = finished_tool_output
+    def _get_step_duration(
+        self, finished_tool_name: str, task_id: str, context_id: str
+    ) -> float | None:
+        """Get step duration from tool panels."""
+        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
+        return self.tool_panels.get(tool_sid, {}).get("duration_seconds")
 
-            # Ensure this finished panel is visible in this frame
-            self.stream_processor.current_event_finished_panels.add(tool_sid)
+    def _finish_delegation_step(
+        self,
+        finished_tool_name: str,
+        finished_tool_output: Any,
+        task_id: str,
+        context_id: str,
+        step_duration: float | None,
+    ) -> None:
+        """Finish a delegation step."""
+        self.steps.finish(
+            task_id=task_id,
+            context_id=context_id,
+            kind="delegate",
+            name=finished_tool_name,
+            output=finished_tool_output,
+            duration_raw=step_duration,
+        )
+
+    def _finish_tool_step_type(
+        self,
+        finished_tool_name: str,
+        finished_tool_output: Any,
+        task_id: str,
+        context_id: str,
+        step_duration: float | None,
+    ) -> None:
+        """Finish a regular tool step."""
+        self.steps.finish(
+            task_id=task_id,
+            context_id=context_id,
+            kind="tool",
+            name=finished_tool_name,
+            output=finished_tool_output,
+            duration_raw=step_duration,
+        )
 
     def _finish_tool_step(
         self,
@@ -477,88 +593,113 @@ class RichStreamRenderer:
         finished_tool_output: Any,
         task_id: str,
         context_id: str,
-    ):
+    ) -> None:
         """Finish the corresponding step for a completed tool."""
-        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-        step_duration = None
-
-        try:
-            step_duration = self.tool_panels.get(tool_sid, {}).get("duration_seconds")
-        except Exception:
-            step_duration = None
+        step_duration = self._get_step_duration(finished_tool_name, task_id, context_id)
 
         if is_delegation_tool(finished_tool_name):
-            self.steps.finish(
-                task_id=task_id,
-                context_id=context_id,
-                kind="delegate",
-                name=finished_tool_name,
-                output=finished_tool_output,
-                duration_raw=step_duration,
+            self._finish_delegation_step(
+                finished_tool_name,
+                finished_tool_output,
+                task_id,
+                context_id,
+                step_duration,
             )
         else:
-            self.steps.finish(
-                task_id=task_id,
-                context_id=context_id,
-                kind="tool",
-                name=finished_tool_name,
-                output=finished_tool_output,
-                duration_raw=step_duration,
+            self._finish_tool_step_type(
+                finished_tool_name,
+                finished_tool_output,
+                task_id,
+                context_id,
+                step_duration,
             )
 
+    def _should_create_snapshot(self, tool_sid: str) -> bool:
+        """Check if a snapshot should be created."""
+        return self.cfg.append_finished_snapshots and not self.tool_panels.get(
+            tool_sid, {}
+        ).get("snapshot_printed")
+
+    def _get_snapshot_title(self, meta: dict[str, Any], finished_tool_name: str) -> str:
+        """Get the title for the snapshot."""
+        adjusted_title = meta.get("title") or finished_tool_name
+
+        # Add elapsed time to title
+        dur = meta.get("duration_seconds")
+        if isinstance(dur, int | float):
+            elapsed_str = self._format_snapshot_duration(dur)
+            adjusted_title = f"{adjusted_title}  · {elapsed_str}"
+
+        return adjusted_title
+
+    def _format_snapshot_duration(self, dur: int | float) -> str:
+        """Format duration for snapshot title."""
+        try:
+            # Handle invalid types
+            if not isinstance(dur, (int, float)):
+                return "<1ms"
+
+            if dur >= 1:
+                return f"{dur:.2f}s"
+            elif int(dur * 1000) > 0:
+                return f"{int(dur * 1000)}ms"
+            else:
+                return "<1ms"
+        except (TypeError, ValueError, OverflowError):
+            return "<1ms"
+
+    def _clamp_snapshot_body(self, body_text: str) -> str:
+        """Clamp snapshot body to configured limits."""
+        max_lines = int(self.cfg.snapshot_max_lines or 0) or 60
+        lines = body_text.splitlines()
+        if len(lines) > max_lines:
+            lines = lines[:max_lines] + ["… (truncated)"]
+        body_text = "\n".join(lines)
+
+        max_chars = int(self.cfg.snapshot_max_chars or 0) or 4000
+        if len(body_text) > max_chars:
+            body_text = body_text[: max_chars - 12] + "\n… (truncated)"
+
+        return body_text
+
+    def _create_snapshot_panel(
+        self, adjusted_title: str, body_text: str, finished_tool_name: str
+    ) -> Any:
+        """Create the snapshot panel."""
+        return create_tool_panel(
+            title=adjusted_title,
+            content=body_text or "(no output)",
+            status="finished",
+            theme=self.cfg.theme,
+            is_delegation=is_delegation_tool(finished_tool_name),
+        )
+
+    def _print_and_mark_snapshot(self, tool_sid: str, snapshot_panel: Any) -> None:
+        """Print snapshot and mark as printed."""
+        self.console.print(snapshot_panel)
+        self.tool_panels[tool_sid]["snapshot_printed"] = True
+
     def _create_tool_snapshot(
         self, finished_tool_name: str, task_id: str, context_id: str
-    ):
+    ) -> None:
         """Create and print a snapshot for a finished tool."""
         tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
 
-        try:
-            if not (
-                self.cfg.append_finished_snapshots
-                and not self.tool_panels.get(tool_sid, {}).get("snapshot_printed")
-            ):
-                return
-
-            meta = self.tool_panels[tool_sid]
-            adjusted_title = meta.get("title") or finished_tool_name
-
-            # Add elapsed time to title
-            dur = meta.get("duration_seconds")
-            if isinstance(dur, int | float):
-                elapsed_str = (
-                    f"{dur:.2f}s"
-                    if dur >= 1
-                    else (f"{int(dur * 1000)}ms" if int(dur * 1000) > 0 else "<1ms")
-                )
-                adjusted_title = f"{adjusted_title}  · {elapsed_str}"
-
-            # Compose body from chunks and clamp
-            body_text = "".join(meta.get("chunks") or [])
-            max_lines = int(self.cfg.snapshot_max_lines or 0) or 60
-            lines = body_text.splitlines()
-            if len(lines) > max_lines:
-                lines = lines[:max_lines] + ["… (truncated)"]
-            body_text = "\n".join(lines)
-
-            max_chars = int(self.cfg.snapshot_max_chars or 0) or 4000
-            if len(body_text) > max_chars:
-                body_text = body_text[: max_chars - 12] + "\n… (truncated)"
-
-            snapshot_panel = create_tool_panel(
-                title=adjusted_title,
-                content=body_text or "(no output)",
-                status="finished",
-                theme=self.cfg.theme,
-                is_delegation=is_delegation_tool(finished_tool_name),
-            )
+        if not self._should_create_snapshot(tool_sid):
+            return
 
-            # Print as a snapshot entry
-            self.console.print(snapshot_panel)
-            # Guard so we don't print snapshot twice
-            self.tool_panels[tool_sid]["snapshot_printed"] = True
+        meta = self.tool_panels[tool_sid]
+        adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
 
-        except Exception:
-            pass
+        # Compose body from chunks and clamp
+        body_text = "".join(meta.get("chunks") or [])
+        body_text = self._clamp_snapshot_body(body_text)
+
+        snapshot_panel = self._create_snapshot_panel(
+            adjusted_title, body_text, finished_tool_name
+        )
+
+        self._print_and_mark_snapshot(tool_sid, snapshot_panel)
 
     def _handle_agent_step(
         self,
@@ -566,8 +707,8 @@ class RichStreamRenderer:
         tool_name: str | None,
         tool_args: Any,
         _tool_out: Any,
-        tool_calls_info: list,
-    ):
+        tool_calls_info: list[tuple[str, Any, Any]],
+    ) -> None:
         """Handle agent step event."""
         metadata = event.get("metadata", {})
         task_id = event.get("task_id")
@@ -587,9 +728,11 @@ class RichStreamRenderer:
         )
 
         # Check for tool completion
-        is_tool_finished, finished_tool_name, finished_tool_output = (
-            self._detect_tool_completion(metadata, content)
-        )
+        (
+            is_tool_finished,
+            finished_tool_name,
+            finished_tool_output,
+        ) = self._detect_tool_completion(metadata, content)
 
         if is_tool_finished and finished_tool_name:
             self._finish_tool_panel(
@@ -614,21 +757,30 @@ class RichStreamRenderer:
 
     def close(self) -> None:
         """Gracefully stop any live rendering and release resources."""
+        self._shutdown_live()
+
+    def __del__(self) -> None:
+        # Destructors must never raise
         try:
-            if self.live:
-                try:
-                    self.live.stop()
-                finally:
-                    self.live = None
-        except Exception:
+            self._shutdown_live(reset_attr=False)
+        except Exception:  # pragma: no cover - destructor safety net
             pass
 
-    def __del__(self):
+    def _shutdown_live(self, reset_attr: bool = True) -> None:
+        """Stop the live renderer without letting exceptions escape."""
+        live = getattr(self, "live", None)
+        if not live:
+            if reset_attr and not hasattr(self, "live"):
+                self.live = None
+            return
+
         try:
-            if self.live:
-                self.live.stop()
+            live.stop()
         except Exception:
-            pass
+            logger.exception("Failed to stop live display")
+        finally:
+            if reset_attr:
+                self.live = None
 
     def _get_analysis_progress_info(self) -> dict[str, Any]:
         total_steps = len(self.steps.order)
@@ -643,15 +795,9 @@ class RichStreamRenderer:
         # Prefer server elapsed time when available
         elapsed = 0.0
         if isinstance(self.stream_processor.server_elapsed_time, int | float):
-            try:
-                elapsed = float(self.stream_processor.server_elapsed_time)
-            except Exception:
-                elapsed = 0.0
+            elapsed = float(self.stream_processor.server_elapsed_time)
         elif self._started_at is not None:
-            try:
-                elapsed = monotonic() - self._started_at
-            except Exception:
-                elapsed = 0.0
+            elapsed = monotonic() - self._started_at
         progress_percent = (
             int((completed_steps / total_steps) * 100) if total_steps else 0
         )
@@ -705,13 +851,13 @@ class RichStreamRenderer:
             return "🧠"
         return ""
 
-    def _format_step_status(self, step) -> str:
+    def _format_step_status(self, step: Step) -> str:
         """Format step status with elapsed time or duration."""
         if is_step_finished(step):
             if step.duration_ms is None:
                 return "[<1ms]"
             elif step.duration_ms >= 1000:
-                return f"[{step.duration_ms/1000:.2f}s]"
+                return f"[{step.duration_ms / 1000:.2f}s]"
             elif step.duration_ms > 0:
                 return f"[{step.duration_ms}ms]"
             return "[<1ms]"
@@ -723,7 +869,7 @@ class RichStreamRenderer:
             ms = int(elapsed * 1000)
             return f"[{ms}ms]" if ms > 0 else "[<1ms]"
 
-    def _calculate_step_elapsed_time(self, step) -> float:
+    def _calculate_step_elapsed_time(self, step: Step) -> float:
         """Calculate elapsed time for a running step."""
         server_elapsed = self.stream_processor.server_elapsed_time
         server_start = self._step_server_start_times.get(step.step_id)
@@ -738,7 +884,7 @@ class RichStreamRenderer:
         except Exception:
             return 0.0
 
-    def _get_step_display_name(self, step) -> str:
+    def _get_step_display_name(self, step: Step) -> str:
         """Get display name for a step."""
         if step.name and step.name != "step":
             return step.name
@@ -779,142 +925,187 @@ class RichStreamRenderer:
 
         return Text("\n".join(lines), style="dim")
 
+    def _should_skip_finished_panel(self, sid: str, status: str) -> bool:
+        """Check if a finished panel should be skipped."""
+        if status != "finished":
+            return False
+
+        if getattr(self.cfg, "append_finished_snapshots", False):
+            return True
+
+        return (
+            not self.state.finalizing_ui
+            and sid not in self.stream_processor.current_event_finished_panels
+        )
+
+    def _calculate_elapsed_time(self, meta: dict[str, Any]) -> str:
+        """Calculate elapsed time string for running tools."""
+        server_elapsed = self.stream_processor.server_elapsed_time
+        server_start = meta.get("server_started_at")
+
+        if isinstance(server_elapsed, int | float) and isinstance(
+            server_start, int | float
+        ):
+            elapsed = max(0.0, float(server_elapsed) - float(server_start))
+        else:
+            elapsed = max(0.0, monotonic() - (meta.get("started_at") or 0.0))
+
+        return self._format_elapsed_time(elapsed)
+
+    def _format_elapsed_time(self, elapsed: float) -> str:
+        """Format elapsed time as a readable string."""
+        if elapsed >= 1:
+            return f"{elapsed:.2f}s"
+        elif int(elapsed * 1000) > 0:
+            return f"{int(elapsed * 1000)}ms"
+        else:
+            return "<1ms"
+
+    def _calculate_finished_duration(self, meta: dict[str, Any]) -> str | None:
+        """Calculate duration string for finished tools."""
+        dur = meta.get("duration_seconds")
+        if isinstance(dur, int | float):
+            return self._format_elapsed_time(dur)
+
+        try:
+            server_now = self.stream_processor.server_elapsed_time
+            server_start = meta.get("server_started_at")
+            if isinstance(server_now, int | float) and isinstance(
+                server_start, int | float
+            ):
+                dur = max(0.0, float(server_now) - float(server_start))
+            elif meta.get("started_at") is not None:
+                dur = max(0.0, float(monotonic() - meta.get("started_at")))
+        except Exception:
+            dur = None
+
+        return self._format_elapsed_time(dur) if isinstance(dur, int | float) else None
+
+    def _process_running_tool_panel(
+        self, title: str, meta: dict[str, Any], body: str
+    ) -> tuple[str, str]:
+        """Process a running tool panel."""
+        elapsed_str = self._calculate_elapsed_time(meta)
+        adjusted_title = f"{title}  · {elapsed_str}"
+        chip = f"⏱ {elapsed_str}"
+
+        if not body:
+            body = chip
+        else:
+            body = f"{body}\n\n{chip}"
+
+        return adjusted_title, body
+
+    def _process_finished_tool_panel(self, title: str, meta: dict[str, Any]) -> str:
+        """Process a finished tool panel."""
+        duration_str = self._calculate_finished_duration(meta)
+        return f"{title}  · {duration_str}" if duration_str else title
+
+    def _create_tool_panel_for_session(
+        self, sid: str, meta: dict[str, Any]
+    ) -> AIPPanel | None:
+        """Create a single tool panel for the session."""
+        title = meta.get("title") or "Tool"
+        status = meta.get("status") or "running"
+        chunks = meta.get("chunks") or []
+        is_delegation = bool(meta.get("is_delegation"))
+
+        if self._should_skip_finished_panel(sid, status):
+            return None
+
+        body = "".join(chunks)
+        adjusted_title = title
+
+        if status == "running":
+            adjusted_title, body = self._process_running_tool_panel(title, meta, body)
+        elif status == "finished":
+            adjusted_title = self._process_finished_tool_panel(title, meta)
+
+        return create_tool_panel(
+            title=adjusted_title,
+            content=body or "Processing...",
+            status=status,
+            theme=self.cfg.theme,
+            is_delegation=is_delegation,
+        )
+
     def _render_tool_panels(self) -> list[AIPPanel]:
         """Render tool execution output panels."""
         panels: list[AIPPanel] = []
         for sid in self.tool_order:
             meta = self.tool_panels.get(sid) or {}
-            title = meta.get("title") or "Tool"
-            status = meta.get("status") or "running"
-            chunks = meta.get("chunks") or []
-            is_delegation = bool(meta.get("is_delegation"))
-
-            # Finished panels visibility rules
-            if status == "finished":
-                if getattr(self.cfg, "append_finished_snapshots", False):
-                    # When snapshots are enabled, don't also render finished panels in the live area
-                    # (prevents duplicates both mid-run and at the end)
-                    continue
-                if (
-                    not self.state.finalizing_ui
-                    and sid not in self.stream_processor.current_event_finished_panels
-                ):
-                    continue
-
-            body = "".join(chunks)
-            adjusted_title = title
-            if status == "running":
-                # Prefer server-based elapsed from when this tool panel started
-                server_elapsed = self.stream_processor.server_elapsed_time
-                server_start = meta.get("server_started_at")
-                if isinstance(server_elapsed, int | float) and isinstance(
-                    server_start, int | float
-                ):
-                    elapsed = max(0.0, float(server_elapsed) - float(server_start))
-                else:
-                    try:
-                        elapsed = max(
-                            0.0, monotonic() - (meta.get("started_at") or 0.0)
-                        )
-                    except Exception:
-                        elapsed = 0.0
-                elapsed_str = (
-                    f"{elapsed:.2f}s"
-                    if elapsed >= 1
-                    else (
-                        f"{int(elapsed * 1000)}ms"
-                        if int(elapsed * 1000) > 0
-                        else "<1ms"
-                    )
-                )
-                # Add a small elapsed hint to the title and panel body (standardized)
-                adjusted_title = f"{title}  · {elapsed_str}"
-                chip = f"⏱ {elapsed_str}"
-                if not body:
-                    body = chip
-                else:
-                    body = f"{body}\n\n{chip}"
-            elif status == "finished":
-                # Use stored duration if present; otherwise try to compute once more
-                dur = meta.get("duration_seconds")
-                if not isinstance(dur, int | float):
-                    try:
-                        server_now = self.stream_processor.server_elapsed_time
-                        server_start = meta.get("server_started_at")
-                        if isinstance(server_now, int | float) and isinstance(
-                            server_start, int | float
-                        ):
-                            dur = max(0.0, float(server_now) - float(server_start))
-                        elif meta.get("started_at") is not None:
-                            dur = max(0.0, float(monotonic() - meta.get("started_at")))
-                    except Exception:
-                        dur = None
-                if isinstance(dur, int | float):
-                    elapsed_str = (
-                        f"{dur:.2f}s"
-                        if dur >= 1
-                        else (f"{int(dur * 1000)}ms" if int(dur * 1000) > 0 else "<1ms")
-                    )
-                    adjusted_title = f"{title}  · {elapsed_str}"
+            panel = self._create_tool_panel_for_session(sid, meta)
+            if panel:
+                panels.append(panel)
 
-            panels.append(
-                create_tool_panel(
-                    title=adjusted_title,
-                    content=body or "Processing...",
-                    status=status,
-                    theme=self.cfg.theme,
-                    is_delegation=is_delegation,
-                )
+        return panels
+
+    def _format_dict_or_list_output(self, output_value: dict | list) -> str:
+        """Format dict/list output as pretty JSON."""
+        try:
+            return (
+                self.OUTPUT_PREFIX
+                + "```json\n"
+                + json.dumps(output_value, indent=2)
+                + "\n```\n"
             )
+        except Exception:
+            return self.OUTPUT_PREFIX + str(output_value) + "\n"
+
+    def _clean_sub_agent_prefix(self, output: str, tool_name: str | None) -> str:
+        """Clean sub-agent name prefix from output."""
+        if not (tool_name and is_delegation_tool(tool_name)):
+            return output
+
+        sub = tool_name
+        if tool_name.startswith("delegate_to_"):
+            sub = tool_name.replace("delegate_to_", "")
+        elif tool_name.startswith("delegate_"):
+            sub = tool_name.replace("delegate_", "")
+        prefix = f"[{sub}]"
+        if output.startswith(prefix):
+            return output[len(prefix) :].lstrip()
+
+        return output
+
+    def _format_json_string_output(self, output: str) -> str:
+        """Format string that looks like JSON."""
+        try:
+            parsed = json.loads(output)
+            return (
+                self.OUTPUT_PREFIX
+                + "```json\n"
+                + json.dumps(parsed, indent=2)
+                + "\n```\n"
+            )
+        except Exception:
+            return self.OUTPUT_PREFIX + output + "\n"
 
-        return panels
+    def _format_string_output(self, output: str, tool_name: str | None) -> str:
+        """Format string output with optional prefix cleaning."""
+        s = output.strip()
+        s = self._clean_sub_agent_prefix(s, tool_name)
 
-    def _format_output_block(self, output_value: Any, tool_name: str | None) -> str:
-        """Format an output value for panel display."""
-        # If dict/list -> pretty JSON
-        if isinstance(output_value, dict | list):
-            try:
-                return (
-                    "**Output:**\n```json\n"
-                    + json.dumps(output_value, indent=2)
-                    + "\n```\n"
-                )
-            except Exception:
-                pass
+        # If looks like JSON, pretty print it
+        if (s.startswith("{") and s.endswith("}")) or (
+            s.startswith("[") and s.endswith("]")
+        ):
+            return self._format_json_string_output(s)
 
-        if isinstance(output_value, str):
-            s = output_value.strip()
-            # Clean sub-agent name prefix like "[research_compiler_agent_testing] "
-            try:
-                if tool_name and is_delegation_tool(tool_name):
-                    sub = tool_name
-                    if tool_name.startswith("delegate_to_"):
-                        sub = tool_name.replace("delegate_to_", "")
-                    elif tool_name.startswith("delegate_"):
-                        sub = tool_name.replace("delegate_", "")
-                    prefix = f"[{sub}]"
-                    if s.startswith(prefix):
-                        s = s[len(prefix) :].lstrip()
-            except Exception:
-                pass
-            # If looks like JSON, pretty print it
-            if (s.startswith("{") and s.endswith("}")) or (
-                s.startswith("[") and s.endswith("]")
-            ):
-                try:
-                    parsed = json.loads(s)
-                    return (
-                        "**Output:**\n```json\n"
-                        + json.dumps(parsed, indent=2)
-                        + "\n```\n"
-                    )
-                except Exception:
-                    pass
-            return "**Output:**\n" + s + "\n"
+        return self.OUTPUT_PREFIX + s + "\n"
 
+    def _format_other_output(self, output_value: Any) -> str:
+        """Format other types of output."""
         try:
-            return "**Output:**\n" + json.dumps(output_value, indent=2) + "\n"
+            return self.OUTPUT_PREFIX + json.dumps(output_value, indent=2) + "\n"
         except Exception:
-            return "**Output:**\n" + str(output_value) + "\n"
+            return self.OUTPUT_PREFIX + str(output_value) + "\n"
 
-    # No legacy surface helpers are exposed; use modern interfaces only
+    def _format_output_block(self, output_value: Any, tool_name: str | None) -> str:
+        """Format an output value for panel display."""
+        if isinstance(output_value, dict | list):
+            return self._format_dict_or_list_output(output_value)
+        elif isinstance(output_value, str):
+            return self._format_string_output(output_value, tool_name)
+        else:
+            return self._format_other_output(output_value)