glaip-sdk 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -16,9 +16,9 @@ from rich.console import Console as RichConsole
 from rich.console import Group
 from rich.live import Live
 from rich.markdown import Markdown
-from rich.panel import Panel
 from rich.text import Text
 
+from glaip_sdk.rich_components import AIPPanel
 from glaip_sdk.utils.rendering.formatting import (
     format_main_title,
     get_spinner_char,
@@ -26,6 +26,7 @@ from glaip_sdk.utils.rendering.formatting import (
 )
 from glaip_sdk.utils.rendering.models import RunStats
 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 (
     create_final_panel,
     create_main_panel,
@@ -41,8 +42,6 @@ from glaip_sdk.utils.rendering.renderer.progress import (
 from glaip_sdk.utils.rendering.renderer.stream import StreamProcessor
 from glaip_sdk.utils.rendering.steps import StepManager
 
-from .debug import render_debug_event
-
 # Configure logger
 logger = logging.getLogger("glaip_sdk.run_renderer")
 
@@ -143,7 +142,7 @@ class RichStreamRenderer:
             )
             if query:
                 self.console.print(
-                    Panel(
+                    AIPPanel(
                         Markdown(f"**Query:** {query}"),
                         title="User Request",
                         border_style="yellow",
@@ -225,7 +224,7 @@ class RichStreamRenderer:
         # Update live display
         self._ensure_live()
 
-    def on_complete(self, stats: RunStats):
+    def on_complete(self, _stats: RunStats):
         """Handle completion event."""
         self.state.finalizing_ui = True
 
@@ -253,6 +252,19 @@ class RichStreamRenderer:
             self.live.stop()
             self.live = None
 
+        # 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
+
     def _ensure_live(self):
         """Ensure live display is updated."""
         # Lazily create Live if needed
@@ -270,7 +282,13 @@ class RichStreamRenderer:
         if self.live:
             panels = [self._render_main_panel()]
             steps_renderable = self._render_steps_text()
-            panels.append(Panel(steps_renderable, title="Steps", border_style="blue"))
+            panels.append(
+                AIPPanel(
+                    steps_renderable,
+                    title="Steps",
+                    border_style="blue",
+                )
+            )
             panels.extend(self._render_tool_panels())
             self.live.update(Group(*panels))
 
@@ -286,79 +304,81 @@ class RichStreamRenderer:
         # Implementation would track thinking states
         pass
 
-    def _handle_agent_step(
+    def _ensure_tool_panel(
+        self, name: str, args: Any, task_id: str, context_id: str
+    ) -> str:
+        """Ensure a tool panel exists and return its ID."""
+        formatted_title = format_tool_title(name)
+        is_delegation = is_delegation_tool(name)
+        tool_sid = f"tool_{name}_{task_id}_{context_id}"
+
+        if tool_sid not in self.tool_panels:
+            self.tool_panels[tool_sid] = {
+                "title": formatted_title,
+                "status": "running",
+                "started_at": monotonic(),
+                "server_started_at": self.stream_processor.server_elapsed_time,
+                "chunks": [],
+                "args": args or {},
+                "output": None,
+                "is_delegation": is_delegation,
+            }
+            # Add Args section once
+            if args:
+                try:
+                    args_content = (
+                        "**Args:**\n```json\n"
+                        + json.dumps(args, indent=2)
+                        + "\n```\n\n"
+                    )
+                except Exception:
+                    args_content = f"**Args:**\n{args}\n\n"
+                self.tool_panels[tool_sid]["chunks"].append(args_content)
+            self.tool_order.append(tool_sid)
+
+        return tool_sid
+
+    def _start_tool_step(
         self,
-        event: dict[str, Any],
-        tool_name: str | None,
+        task_id: str,
+        context_id: str,
+        tool_name: str,
         tool_args: Any,
-        tool_out: Any,
-        tool_calls_info: list,
+        _tool_sid: str,
     ):
-        """Handle agent step event."""
-        metadata = event.get("metadata", {})
-        task_id = event.get("task_id")
-        context_id = event.get("context_id")
-        content = event.get("content", "")
+        """Start or get a step for a tool."""
+        if is_delegation_tool(tool_name):
+            st = self.steps.start_or_get(
+                task_id=task_id,
+                context_id=context_id,
+                kind="delegate",
+                name=tool_name,
+                args=tool_args,
+            )
+        else:
+            st = self.steps.start_or_get(
+                task_id=task_id,
+                context_id=context_id,
+                kind="tool",
+                name=tool_name,
+                args=tool_args,
+            )
 
-        def ensure_tool_panel(name: str, args: Any) -> str:
-            formatted_title = format_tool_title(name)
-            is_delegation = is_delegation_tool(name)
-            tool_sid = f"tool_{name}_{task_id}_{context_id}"
-            if tool_sid not in self.tool_panels:
-                self.tool_panels[tool_sid] = {
-                    "title": formatted_title,
-                    "status": "running",
-                    "started_at": monotonic(),
-                    "server_started_at": self.stream_processor.server_elapsed_time,
-                    "chunks": [],
-                    "args": args or {},
-                    "output": None,
-                    "is_delegation": is_delegation,
-                }
-                # Add Args section once
-                if args:
-                    try:
-                        args_content = (
-                            "**Args:**\n```json\n"
-                            + json.dumps(args, indent=2)
-                            + "\n```\n\n"
-                        )
-                    except Exception:
-                        args_content = f"**Args:**\n{args}\n\n"
-                    self.tool_panels[tool_sid]["chunks"].append(args_content)
-                self.tool_order.append(tool_sid)
-            return tool_sid
+        # Record server start time for this step if available
+        if st and self.stream_processor.server_elapsed_time is not None:
+            self._step_server_start_times[st.step_id] = (
+                self.stream_processor.server_elapsed_time
+            )
 
-        # Create steps and panels for the primary tool
-        if tool_name:
-            tool_sid = ensure_tool_panel(tool_name, tool_args)
-            # Start or get a step for this tool
-            if is_delegation_tool(tool_name):
-                st = self.steps.start_or_get(
-                    task_id=task_id,
-                    context_id=context_id,
-                    kind="delegate",
-                    name=tool_name,
-                    args=tool_args,
-                )
-            else:
-                st = self.steps.start_or_get(
-                    task_id=task_id,
-                    context_id=context_id,
-                    kind="tool",
-                    name=tool_name,
-                    args=tool_args,
-                )
-            # Record server start time for this step if available
-            if st and self.stream_processor.server_elapsed_time is not None:
-                self._step_server_start_times[st.step_id] = (
-                    self.stream_processor.server_elapsed_time
-                )
+        return st
 
-        # Handle additional tool calls (avoid duplicates)
+    def _process_additional_tool_calls(
+        self, tool_calls_info: list, tool_name: str, task_id: str, context_id: str
+    ):
+        """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:
-                ensure_tool_panel(call_name, call_args)
+                self._ensure_tool_panel(call_name, call_args, task_id, context_id)
                 if is_delegation_tool(call_name):
                     st2 = self.steps.start_or_get(
                         task_id=task_id,
@@ -380,141 +400,205 @@ class RichStreamRenderer:
                         self.stream_processor.server_elapsed_time
                     )
 
-        # Check completion status hints
+    def _detect_tool_completion(
+        self, metadata: dict, content: str
+    ) -> tuple[bool, str | None, Any]:
+        """Detect if a tool has completed and return completion info."""
         tool_info = metadata.get("tool_info", {}) if isinstance(metadata, dict) else {}
-        is_tool_finished = False
-        finished_tool_name: str | None = None
-        finished_tool_output: Any = None
 
         if tool_info.get("status") == "finished" and tool_info.get("name"):
-            is_tool_finished = True
-            finished_tool_name = tool_info.get("name")
-            finished_tool_output = tool_info.get("output")
+            return True, tool_info.get("name"), tool_info.get("output")
         elif content and isinstance(content, str) and content.startswith("Completed "):
             # content like "Completed google_serper"
             tname = content.replace("Completed ", "").strip()
             if tname:
-                is_tool_finished = True
-                finished_tool_name = tname
-                if tool_info.get("name") == tname:
-                    finished_tool_output = tool_info.get("output")
+                output = (
+                    tool_info.get("output") if tool_info.get("name") == tname else None
+                )
+                return True, tname, output
         elif metadata.get("status") == "finished" and tool_info.get("name"):
-            is_tool_finished = True
-            finished_tool_name = tool_info.get("name")
-            finished_tool_output = tool_info.get("output")
+            return True, tool_info.get("name"), tool_info.get("output")
 
-        if is_tool_finished and finished_tool_name:
-            # Update panel
-            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")
+        return False, None, None
+
+    def _finish_tool_panel(
+        self,
+        finished_tool_name: str,
+        finished_tool_output: Any,
+        task_id: str,
+        context_id: str,
+    ):
+        """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")
+
+            if prev_status != "finished":
                 meta["status"] = "finished"
-                # Compute and store duration for finished panel
-                if prev_status != "finished":
-                    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
 
-                    if finished_tool_output is not None:
-                        meta["chunks"].append(
-                            self._format_output_block(
-                                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["output"] = finished_tool_output
-                # Ensure this finished panel is visible in this frame
-                self.stream_processor.current_event_finished_panels.add(tool_sid)
+                        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
+
+            # Ensure this finished panel is visible in this frame
+            self.stream_processor.current_event_finished_panels.add(tool_sid)
+
+    def _finish_tool_step(
+        self,
+        finished_tool_name: str,
+        finished_tool_output: Any,
+        task_id: str,
+        context_id: str,
+    ):
+        """Finish the corresponding step for a completed tool."""
+        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
+        step_duration = None
 
-            # Finish corresponding step, pass duration to match panel title
+        try:
+            step_duration = self.tool_panels.get(tool_sid, {}).get("duration_seconds")
+        except Exception:
             step_duration = None
-            try:
-                step_duration = self.tool_panels.get(tool_sid, {}).get(
-                    "duration_seconds"
-                )
-            except Exception:
-                step_duration = None
-            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,
-                )
-            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,
+
+        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,
+            )
+        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,
+            )
+
+    def _create_tool_snapshot(
+        self, finished_tool_name: str, task_id: str, context_id: str
+    ):
+        """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),
+            )
 
-            # Append a truncated snapshot to scrollback so user can freely scroll
-            try:
-                if self.cfg.append_finished_snapshots and not self.tool_panels.get(
-                    tool_sid, {}
-                ).get("snapshot_printed"):
-                    # Build title with elapsed if available
-                    adjusted_title = meta.get("title") or finished_tool_name
-                    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 [])
-                    # Clamp by lines then by chars
-                    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),
-                    )
-                    # Print as a snapshot entry; when Live is active this prints above the live area
-                    self.console.print(snapshot_panel)
-                    # Guard so we don't print snapshot twice for repeated finish events
-                    self.tool_panels[tool_sid]["snapshot_printed"] = True
-            except Exception:
-                pass
+            # 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
+
+        except Exception:
+            pass
+
+    def _handle_agent_step(
+        self,
+        event: dict[str, Any],
+        tool_name: str | None,
+        tool_args: Any,
+        _tool_out: Any,
+        tool_calls_info: list,
+    ):
+        """Handle agent step event."""
+        metadata = event.get("metadata", {})
+        task_id = event.get("task_id")
+        context_id = event.get("context_id")
+        content = event.get("content", "")
+
+        # Create steps and panels for the primary tool
+        if tool_name:
+            tool_sid = self._ensure_tool_panel(
+                tool_name, tool_args, task_id, context_id
+            )
+            self._start_tool_step(task_id, context_id, tool_name, tool_args, tool_sid)
+
+        # Handle additional tool calls
+        self._process_additional_tool_calls(
+            tool_calls_info, tool_name, task_id, context_id
+        )
+
+        # Check for tool completion
+        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(
+                finished_tool_name, finished_tool_output, task_id, context_id
+            )
+            self._finish_tool_step(
+                finished_tool_name, finished_tool_output, task_id, context_id
+            )
+            self._create_tool_snapshot(finished_tool_name, task_id, context_id)
 
     def _spinner(self) -> str:
         """Return spinner character."""
@@ -600,7 +684,7 @@ class RichStreamRenderer:
 
     # Modern interface only — no legacy helper shims below
 
-    def _refresh(self, force: bool | None = None) -> None:
+    def _refresh(self, _force: bool | None = None) -> None:
         # In the modular renderer, refreshing simply updates the live group
         self._ensure_live()
 
@@ -611,84 +695,93 @@ class RichStreamRenderer:
                 return True
         return False
 
-    def _render_steps_text(self) -> Text:
-        """Render the steps panel content."""
-        if not (self.steps.order or self.steps.children):
-            return Text("No steps yet", style="dim")
+    def _get_step_icon(self, step_kind: str) -> str:
+        """Get icon for step kind."""
+        if step_kind == "tool":
+            return "⚙️"
+        elif step_kind == "delegate":
+            return "🤝"
+        elif step_kind == "agent":
+            return "🧠"
+        return ""
+
+    def _format_step_status(self, 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]"
+            elif step.duration_ms > 0:
+                return f"[{step.duration_ms}ms]"
+            return "[<1ms]"
+        else:
+            # Calculate elapsed time for running steps
+            elapsed = self._calculate_step_elapsed_time(step)
+            if elapsed >= 1:
+                return f"[{elapsed:.2f}s]"
+            ms = int(elapsed * 1000)
+            return f"[{ms}ms]" if ms > 0 else "[<1ms]"
+
+    def _calculate_step_elapsed_time(self, 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)
+
+        if isinstance(server_elapsed, int | float) and isinstance(
+            server_start, int | float
+        ):
+            return max(0.0, float(server_elapsed) - float(server_start))
 
-        # Track running tools by task/context to annotate parallelism
+        try:
+            return max(0.0, float(monotonic() - step.started_at))
+        except Exception:
+            return 0.0
+
+    def _get_step_display_name(self, step) -> str:
+        """Get display name for a step."""
+        if step.name and step.name != "step":
+            return step.name
+        return "thinking..." if step.kind == "agent" else f"{step.kind} step"
+
+    def _check_parallel_tools(self) -> dict[tuple[str | None, str | None], list]:
+        """Check for parallel running tools."""
         running_by_ctx: dict[tuple[str | None, str | None], list] = {}
         for sid in self.steps.order:
             st = self.steps.by_id[sid]
             if st.kind == "tool" and not is_step_finished(st):
                 key = (st.task_id, st.context_id)
                 running_by_ctx.setdefault(key, []).append(st)
+        return running_by_ctx
 
+    def _render_steps_text(self) -> Text:
+        """Render the steps panel content."""
+        if not (self.steps.order or self.steps.children):
+            return Text("No steps yet", style="dim")
+
+        running_by_ctx = self._check_parallel_tools()
         lines: list[str] = []
+
         for sid in self.steps.order:
             st = self.steps.by_id[sid]
-            # Determine elapsed/status label
-            if is_step_finished(st):
-                if st.duration_ms is None:
-                    status_br = "[<1ms]"
-                elif st.duration_ms >= 1000:
-                    status_br = f"[{st.duration_ms/1000:.2f}s]"
-                elif st.duration_ms > 0:
-                    status_br = f"[{st.duration_ms}ms]"
-                else:
-                    status_br = "[<1ms]"
-            else:
-                # Prefer server timing when we have a server start timestamp
-                server_elapsed = self.stream_processor.server_elapsed_time
-                server_start = self._step_server_start_times.get(st.step_id)
-                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, float(monotonic() - st.started_at))
-                    except Exception:
-                        elapsed = 0.0
-                # Standardized elapsed label without "Working..."
-                if elapsed >= 1:
-                    status_br = f"[{elapsed:.2f}s]"
-                else:
-                    ms = int(elapsed * 1000)
-                    status_br = f"[{ms}ms]" if ms > 0 else "[<1ms]"
-
-            display_name = (
-                st.name
-                if st.name and st.name != "step"
-                else ("thinking..." if st.kind == "agent" else f"{st.kind} step")
-            )
+            status_br = self._format_step_status(st)
+            display_name = self._get_step_display_name(st)
             tail = " ✓" if is_step_finished(st) else ""
 
-            # Parallel indicator for running tools
-            parallel_indicator = ""
+            # Add parallel indicator for running tools
             if st.kind == "tool" and not is_step_finished(st):
                 key = (st.task_id, st.context_id)
                 if len(running_by_ctx.get(key, [])) > 1:
-                    parallel_indicator = " 🔄"
-                    status_br = status_br.replace("]", f"{parallel_indicator}]")
-
-            # Icon prefix (simple mapping)
-            if st.kind == "tool":
-                icon = "⚙️"
-            elif st.kind == "delegate":
-                icon = "🤝"
-            elif st.kind == "agent":
-                icon = "🧠"
-            else:
-                icon = ""
+                    status_br = status_br.replace("]", " 🔄]")
 
+            icon = self._get_step_icon(st.kind)
             lines.append(f"{icon} {display_name} {status_br}{tail}")
 
         return Text("\n".join(lines), style="dim")
 
-    def _render_tool_panels(self) -> list[Panel]:
+    def _render_tool_panels(self) -> list[AIPPanel]:
         """Render tool execution output panels."""
-        panels: list[Panel] = []
+        panels: list[AIPPanel] = []
         for sid in self.tool_order:
             meta = self.tool_panels.get(sid) or {}
             title = meta.get("title") or "Tool"