glaip-sdk 0.0.5__py3-none-any.whl → 0.0.6a0__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
@@ -209,9 +212,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,7 +230,7 @@ class RichStreamRenderer:
         # Update live display
         self._ensure_live()
 
-    def on_complete(self, _stats: RunStats):
+    def on_complete(self, _stats: RunStats) -> None:
         """Handle completion event."""
         self.state.finalizing_ui = True
 
@@ -265,7 +271,7 @@ class RichStreamRenderer:
             # Non-fatal; renderer best-effort
             pass
 
-    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 +298,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 +353,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 +381,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 +433,123 @@ 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."""
+        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")))
+
+            return dur
+        except Exception:
+            return None
+
+    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}"
+        try:
+            return self.tool_panels.get(tool_sid, {}).get("duration_seconds")
+        except Exception:
+            return None
 
-            # 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,85 +557,114 @@ 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")
-            ):
+            tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
+
+            if not self._should_create_snapshot(tool_sid):
                 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}"
+            adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
 
             # 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),
+            body_text = self._clamp_snapshot_body(body_text)
+
+            snapshot_panel = self._create_snapshot_panel(
+                adjusted_title, body_text, finished_tool_name
             )
 
-            # 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
+            self._print_and_mark_snapshot(tool_sid, snapshot_panel)
 
         except Exception:
             pass
@@ -566,8 +675,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 +696,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(
@@ -623,7 +734,7 @@ class RichStreamRenderer:
         except Exception:
             pass
 
-    def __del__(self):
+    def __del__(self) -> None:
         try:
             if self.live:
                 self.live.stop()
@@ -705,13 +816,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 +834,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 +849,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 +890,195 @@ 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:
+            try:
+                elapsed = max(0.0, monotonic() - (meta.get("started_at") or 0.0))
+            except Exception:
+                elapsed = 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"
 
-        return panels
+    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
 
-    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
+        try:
+            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()
+        except Exception:
+            pass
 
-        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 output
 
+    def _format_json_string_output(self, output: str) -> str:
+        """Format string that looks like JSON."""
         try:
-            return "**Output:**\n" + json.dumps(output_value, indent=2) + "\n"
+            parsed = json.loads(output)
+            return (
+                self.OUTPUT_PREFIX
+                + "```json\n"
+                + json.dumps(parsed, indent=2)
+                + "\n```\n"
+            )
         except Exception:
-            return "**Output:**\n" + str(output_value) + "\n"
+            return self.OUTPUT_PREFIX + output + "\n"
+
+    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)
+
+        # 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)
+
+        return self.OUTPUT_PREFIX + s + "\n"
+
+    def _format_other_output(self, output_value: Any) -> str:
+        """Format other types of output."""
+        try:
+            return self.OUTPUT_PREFIX + json.dumps(output_value, indent=2) + "\n"
+        except Exception:
+            return self.OUTPUT_PREFIX + str(output_value) + "\n"
+
+    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)
 
     # No legacy surface helpers are exposed; use modern interfaces only