glaip-sdk 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -219,12 +219,8 @@ class RichStreamRenderer:
         self._transcript_mode_enabled: bool = False
         self._transcript_render_cursor: int = 0
         self.transcript_controller: Any | None = None
-        self._transcript_hint_message = (
-            "[dim]Transcript view · Press Ctrl+T to return to the summary.[/dim]"
-        )
-        self._summary_hint_message = (
-            "[dim]Press Ctrl+T to inspect raw transcript events.[/dim]"
-        )
+        self._transcript_hint_message = "[dim]Transcript view · Press Ctrl+T to return to the summary.[/dim]"
+        self._summary_hint_message = "[dim]Press Ctrl+T to inspect raw transcript events.[/dim]"
         self._summary_hint_printed_once: bool = False
         self._transcript_hint_printed_once: bool = False
         self._transcript_header_printed: bool = False
@@ -245,9 +241,7 @@ class RichStreamRenderer:
 
         meta_payload = meta or {}
         self.steps.set_root_agent(meta_payload.get("agent_id"))
-        self._root_agent_friendly = self._humanize_agent_slug(
-            meta_payload.get("agent_name")
-        )
+        self._root_agent_friendly = self._humanize_agent_slug(meta_payload.get("agent_name"))
         self._root_query = _truncate_display(
             meta_payload.get("input_message")
             or meta_payload.get("query")
@@ -383,9 +377,7 @@ class RichStreamRenderer:
 
         return received_at
 
-    def _sync_stream_start(
-        self, ev: dict[str, Any], received_at: datetime | None
-    ) -> None:
+    def _sync_stream_start(self, ev: dict[str, Any], received_at: datetime | None) -> None:
         """Ensure renderer and stream processor share a streaming baseline."""
         baseline = self.state.streaming_started_at
         if baseline is None:
@@ -442,9 +434,7 @@ class RichStreamRenderer:
             self.state.buffer.append(content)
             self._ensure_live()
 
-    def _handle_final_response_event(
-        self, content: str, metadata: dict[str, Any]
-    ) -> None:
+    def _handle_final_response_event(self, content: str, metadata: dict[str, Any]) -> None:
         """Handle final response events."""
         if content:
             self.state.buffer.append(content)
@@ -464,17 +454,12 @@ class RichStreamRenderer:
     def _normalise_finished_icons(self) -> None:
         """Ensure finished steps do not keep spinner icons."""
         for step in self.steps.by_id.values():
-            if (
-                getattr(step, "status", None) == "finished"
-                and getattr(step, "status_icon", None) == "spinner"
-            ):
+            if getattr(step, "status", None) == "finished" and getattr(step, "status_icon", None) == "spinner":
                 step.status_icon = "success"
             if getattr(step, "status", None) != "running":
                 self._step_spinners.pop(step.step_id, None)
 
-    def _handle_agent_step_event(
-        self, ev: dict[str, Any], metadata: dict[str, Any]
-    ) -> None:
+    def _handle_agent_step_event(self, ev: dict[str, Any], metadata: dict[str, Any]) -> None:
         """Handle agent step events."""
         # Extract tool information
         (
@@ -498,9 +483,7 @@ class RichStreamRenderer:
             self._maybe_attach_root_query(tracked_step)
 
         # Track tools and sub-agents for transcript/debug context
-        self.stream_processor.track_tools_and_agents(
-            tool_name, tool_calls_info, is_delegation_tool
-        )
+        self.stream_processor.track_tools_and_agents(tool_name, tool_calls_info, is_delegation_tool)
 
         # Handle tool execution
         self._handle_agent_step(
@@ -517,13 +500,7 @@ class RichStreamRenderer:
 
     def _maybe_attach_root_query(self, step: Step | None) -> None:
         """Attach the user query to the root agent step for display."""
-        if (
-            not step
-            or self._root_query_attached
-            or not self._root_query
-            or step.kind != "agent"
-            or step.parent_id
-        ):
+        if not step or self._root_query_attached or not self._root_query or step.kind != "agent" or step.parent_id:
             return
 
         args = dict(getattr(step, "args", {}) or {})
@@ -531,9 +508,7 @@ class RichStreamRenderer:
         step.args = args
         self._root_query_attached = True
 
-    def _record_step_server_start(
-        self, step: Step | None, payload: dict[str, Any]
-    ) -> None:
+    def _record_step_server_start(self, step: Step | None, payload: dict[str, Any]) -> None:
         """Store server-provided start times for elapsed calculations."""
         if not step:
             return
@@ -542,29 +517,21 @@ class RichStreamRenderer:
             return
         self._step_server_start_times.setdefault(step.step_id, float(server_time))
 
-    def _maybe_override_root_agent_label(
-        self, step: Step | None, payload: dict[str, Any]
-    ) -> None:
+    def _maybe_override_root_agent_label(self, step: Step | None, payload: dict[str, Any]) -> None:
         """Ensure the root agent row uses the human-friendly name and shows the ID."""
         if not step or step.kind != "agent" or step.parent_id:
             return
-        friendly = self._root_agent_friendly or self._humanize_agent_slug(
-            (payload or {}).get("agent_name")
-        )
+        friendly = self._root_agent_friendly or self._humanize_agent_slug((payload or {}).get("agent_name"))
         if not friendly:
             return
         agent_identifier = step.name or step.step_id
         if not agent_identifier:
             return
-        step.display_label = normalise_display_label(
-            f"{ICON_AGENT} {friendly} ({agent_identifier})"
-        )
+        step.display_label = normalise_display_label(f"{ICON_AGENT} {friendly} ({agent_identifier})")
         if not self._root_agent_step_id:
             self._root_agent_step_id = step.step_id
 
-    def _update_thinking_timeline(
-        self, step: Step | None, payload: dict[str, Any]
-    ) -> None:
+    def _update_thinking_timeline(self, step: Step | None, payload: dict[str, Any]) -> None:
         """Maintain deterministic thinking spans for each agent/delegate scope."""
         if not self.cfg.render_thinking or not step:
             return
@@ -609,9 +576,7 @@ class RichStreamRenderer:
                 start_monotonic=now_monotonic,
             )
 
-        is_anchor_finished = status_hint in FINISHED_STATUS_HINTS or (
-            not status_hint and is_step_finished(step)
-        )
+        is_anchor_finished = status_hint in FINISHED_STATUS_HINTS or (not status_hint and is_step_finished(step))
         if is_anchor_finished:
             scope.anchor_finished_at = server_time or scope.anchor_finished_at
             self._finish_scope_thinking(scope, server_time, now_monotonic)
@@ -641,13 +606,9 @@ class RichStreamRenderer:
         if not parent_scope or parent_scope.closed:
             return
         if is_finished:
-            self._mark_child_finished(
-                parent_scope, child_step.step_id, server_time, now_monotonic
-            )
+            self._mark_child_finished(parent_scope, child_step.step_id, server_time, now_monotonic)
         else:
-            self._mark_child_running(
-                parent_scope, child_step, server_time, now_monotonic
-            )
+            self._mark_child_running(parent_scope, child_step, server_time, now_monotonic)
 
     def _update_child_thinking(
         self,
@@ -666,9 +627,7 @@ class RichStreamRenderer:
         if not scope or scope.closed or step.kind == "thinking":
             return
 
-        is_finish_event = status_hint in FINISHED_STATUS_HINTS or (
-            not status_hint and is_step_finished(step)
-        )
+        is_finish_event = status_hint in FINISHED_STATUS_HINTS or (not status_hint and is_step_finished(step))
         if is_finish_event:
             self._mark_child_finished(scope, step.step_id, server_time, now_monotonic)
         else:
@@ -967,7 +926,8 @@ class RichStreamRenderer:
         if self._transcript_mode_enabled:
             try:
                 self.console.print(
-                    "[dim]Run finished. Press Ctrl+T to return to the summary view or stay here to inspect events. Use the post-run viewer for export.[/dim]"
+                    "[dim]Run finished. Press Ctrl+T to return to the summary view or stay here to inspect events. "
+                    "Use the post-run viewer for export.[/dim]"
                 )
             except Exception:
                 pass
@@ -1172,9 +1132,7 @@ class RichStreamRenderer:
         if self._transcript_enabled_message_printed:
             return
         try:
-            self.console.print(
-                "[dim]Transcript mode enabled — streaming raw transcript events.[/dim]"
-            )
+            self.console.print("[dim]Transcript mode enabled — streaming raw transcript events.[/dim]")
         except Exception:
             pass
         else:
@@ -1226,9 +1184,7 @@ class RichStreamRenderer:
         self._transcript_render_cursor = len(self.state.events)
         self._print_transcript_hint()
 
-    def _capture_event(
-        self, ev: dict[str, Any], received_at: datetime | None = None
-    ) -> None:
+    def _capture_event(self, ev: dict[str, Any], received_at: datetime | None = None) -> None:
         """Capture a deep copy of SSE events for transcript replay."""
         try:
             captured = json.loads(json.dumps(ev))
@@ -1256,9 +1212,7 @@ class RichStreamRenderer:
         """Return captured SSE events."""
         return list(self.state.events)
 
-    def _ensure_tool_panel(
-        self, name: str, args: Any, task_id: str, context_id: str
-    ) -> str:
+    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)
@@ -1278,11 +1232,7 @@ class RichStreamRenderer:
             # Add Args section once
             if args:
                 try:
-                    args_content = (
-                        "**Args:**\n```json\n"
-                        + json.dumps(args, indent=2)
-                        + "\n```\n\n"
-                    )
+                    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)
@@ -1322,9 +1272,7 @@ class RichStreamRenderer:
 
         # 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
-            )
+            self._step_server_start_times[st.step_id] = self.stream_processor.server_elapsed_time
 
         return st
 
@@ -1338,26 +1286,18 @@ class RichStreamRenderer:
         """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:
-                self._process_single_tool_call(
-                    call_name, call_args, task_id, context_id
-                )
+                self._process_single_tool_call(call_name, call_args, task_id, context_id)
 
-    def _process_single_tool_call(
-        self, call_name: str, call_args: Any, task_id: str, context_id: str
-    ) -> None:
+    def _process_single_tool_call(self, call_name: str, call_args: Any, task_id: str, context_id: str) -> None:
         """Process a single additional tool call."""
         self._ensure_tool_panel(call_name, call_args, task_id, context_id)
 
         st2 = self._create_step_for_tool_call(call_name, call_args, task_id, context_id)
 
         if self.stream_processor.server_elapsed_time is not None and st2:
-            self._step_server_start_times[st2.step_id] = (
-                self.stream_processor.server_elapsed_time
-            )
+            self._step_server_start_times[st2.step_id] = self.stream_processor.server_elapsed_time
 
-    def _create_step_for_tool_call(
-        self, call_name: str, call_args: Any, task_id: str, context_id: str
-    ) -> Any:
+    def _create_step_for_tool_call(self, call_name: str, call_args: Any, task_id: str, context_id: str) -> Any:
         """Create appropriate step for tool call."""
         if is_delegation_tool(call_name):
             return self.steps.start_or_get(
@@ -1376,9 +1316,7 @@ class RichStreamRenderer:
                 args=call_args,
             )
 
-    def _detect_tool_completion(
-        self, metadata: dict, content: str
-    ) -> tuple[bool, str | None, Any]:
+    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 {}
 
@@ -1388,18 +1326,14 @@ class RichStreamRenderer:
             # content like "Completed google_serper"
             tname = content.replace("Completed ", "").strip()
             if tname:
-                output = (
-                    tool_info.get("output") if tool_info.get("name") == tname else None
-                )
+                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"):
             return True, tool_info.get("name"), tool_info.get("output")
 
         return False, None, None
 
-    def _get_tool_session_id(
-        self, finished_tool_name: str, task_id: str, context_id: str
-    ) -> str:
+    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}"
 
@@ -1429,7 +1363,7 @@ class RichStreamRenderer:
             meta["duration_seconds"] = dur
             meta["server_finished_at"] = (
                 self.stream_processor.server_elapsed_time
-                if isinstance(self.stream_processor.server_elapsed_time, int | float)
+                if isinstance(self.stream_processor.server_elapsed_time, (int, float))
                 else None
             )
             meta["finished_at"] = monotonic()
@@ -1439,9 +1373,7 @@ class RichStreamRenderer:
     ) -> 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["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:
@@ -1471,9 +1403,7 @@ class RichStreamRenderer:
         self._mark_panel_as_finished(meta, tool_sid)
         self._add_tool_output_to_panel(meta, finished_tool_output, finished_tool_name)
 
-    def _get_step_duration(
-        self, finished_tool_name: str, task_id: str, context_id: str
-    ) -> float | None:
+    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")
@@ -1548,9 +1478,7 @@ class RichStreamRenderer:
 
     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")
+        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."""
@@ -1558,7 +1486,7 @@ class RichStreamRenderer:
 
         # Add elapsed time to title
         dur = meta.get("duration_seconds")
-        if isinstance(dur, int | float):
+        if isinstance(dur, (int, float)):
             elapsed_str = self._format_snapshot_duration(dur)
             adjusted_title = f"{adjusted_title}  · {elapsed_str}"
 
@@ -1595,9 +1523,7 @@ class RichStreamRenderer:
 
         return body_text
 
-    def _create_snapshot_panel(
-        self, adjusted_title: str, body_text: str, finished_tool_name: str
-    ) -> Any:
+    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,
@@ -1612,9 +1538,7 @@ class RichStreamRenderer:
         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:
+    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}"
 
@@ -1628,9 +1552,7 @@ class RichStreamRenderer:
         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
-        )
+        snapshot_panel = self._create_snapshot_panel(adjusted_title, body_text, finished_tool_name)
 
         self._print_and_mark_snapshot(tool_sid, snapshot_panel)
 
@@ -1652,9 +1574,7 @@ class RichStreamRenderer:
 
         # 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
-            )
+            tool_sid = self._ensure_tool_panel(tool_name, tool_args, task_id, context_id)
             self._start_tool_step(
                 task_id,
                 context_id,
@@ -1665,9 +1585,7 @@ class RichStreamRenderer:
             )
 
         # Handle additional tool calls
-        self._process_additional_tool_calls(
-            tool_calls_info, tool_name, task_id, context_id
-        )
+        self._process_additional_tool_calls(tool_calls_info, tool_name, task_id, context_id)
 
         # Check for tool completion
         (
@@ -1677,9 +1595,7 @@ class RichStreamRenderer:
         ) = 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_panel(finished_tool_name, finished_tool_output, task_id, context_id)
             self._finish_tool_step(
                 finished_tool_name,
                 finished_tool_output,
@@ -1735,9 +1651,7 @@ class RichStreamRenderer:
 
     def _get_analysis_progress_info(self) -> dict[str, Any]:
         total_steps = len(self.steps.order)
-        completed_steps = sum(
-            1 for sid in self.steps.order if is_step_finished(self.steps.by_id[sid])
-        )
+        completed_steps = sum(1 for sid in self.steps.order if is_step_finished(self.steps.by_id[sid]))
         current_step = None
         for sid in self.steps.order:
             if not is_step_finished(self.steps.by_id[sid]):
@@ -1745,13 +1659,11 @@ class RichStreamRenderer:
                 break
         # Prefer server elapsed time when available
         elapsed = 0.0
-        if isinstance(self.stream_processor.server_elapsed_time, int | float):
+        if isinstance(self.stream_processor.server_elapsed_time, (int, float)):
             elapsed = float(self.stream_processor.server_elapsed_time)
         elif self._started_at is not None:
             elapsed = monotonic() - self._started_at
-        progress_percent = (
-            int((completed_steps / total_steps) * 100) if total_steps else 0
-        )
+        progress_percent = int((completed_steps / total_steps) * 100) if total_steps else 0
         return {
             "total_steps": total_steps,
             "completed_steps": completed_steps,
@@ -1840,9 +1752,7 @@ class RichStreamRenderer:
         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
-        ):
+        if isinstance(server_elapsed, (int, float)) and isinstance(server_start, (int, float)):
             return max(0.0, float(server_elapsed) - float(server_start))
 
         try:
@@ -1921,9 +1831,7 @@ class RichStreamRenderer:
         self._append_state_glyph(text_line, step)
         return text_line
 
-    def _append_status_badge(
-        self, text_line: Text, step: Step, status_badge: str
-    ) -> None:
+    def _append_status_badge(self, text_line: Text, step: Step, status_badge: str) -> None:
         """Append the formatted status badge when available."""
         glyph_key = getattr(step, "status_icon", None)
         glyph = glyph_for_status(glyph_key)
@@ -1993,9 +1901,7 @@ class RichStreamRenderer:
         args_text.append(formatted_args, style="dim")
         return args_text
 
-    def _build_arg_list(
-        self, prefix: str, formatted_args: list[str | tuple[int, str]]
-    ) -> Group | None:
+    def _build_arg_list(self, prefix: str, formatted_args: list[str | tuple[int, str]]) -> Group | None:
         """Render multi-line argument entries preserving indentation."""
         arg_lines: list[Text] = []
         for indent_level, text_value in self._iter_arg_entries(formatted_args):
@@ -2021,9 +1927,7 @@ class RichStreamRenderer:
             else:
                 yield 0, str(value)
 
-    def _format_step_args(
-        self, step: Step
-    ) -> str | list[str] | list[tuple[int, str]] | None:
+    def _format_step_args(self, step: Step) -> str | list[str] | list[tuple[int, str]] | None:
         """Return a printable representation of tool arguments."""
         args = getattr(step, "args", None)
         if args is None:
@@ -2040,9 +1944,7 @@ class RichStreamRenderer:
 
         return None
 
-    def _format_dict_args(
-        self, args: dict[str, Any], *, step: Step
-    ) -> str | list[str] | list[tuple[int, str]] | None:
+    def _format_dict_args(self, args: dict[str, Any], *, step: Step) -> str | list[str] | list[tuple[int, str]] | None:
         """Format dictionary arguments with guardrails."""
         if not args:
             return None
@@ -2085,9 +1987,7 @@ class RichStreamRenderer:
             return True
         return False
 
-    def _format_dict_arg_lines(
-        self, args: dict[str, Any]
-    ) -> list[tuple[int, str]] | None:
+    def _format_dict_arg_lines(self, args: dict[str, Any]) -> list[tuple[int, str]] | None:
         """Render dictionary arguments as nested YAML-style lines."""
         lines: list[tuple[int, str]] = []
         for raw_key, value in args.items():
@@ -2095,9 +1995,7 @@ class RichStreamRenderer:
             lines.extend(self._format_nested_entry(key, value, indent=0))
         return lines or None
 
-    def _format_nested_entry(
-        self, key: str, value: Any, indent: int
-    ) -> list[tuple[int, str]]:
+    def _format_nested_entry(self, key: str, value: Any, indent: int) -> list[tuple[int, str]]:
         """Format a mapping entry recursively."""
         lines: list[tuple[int, str]] = []
 
@@ -2123,9 +2021,7 @@ class RichStreamRenderer:
             lines.append((indent, f"{key}: {formatted_value}"))
         return lines
 
-    def _format_nested_mapping(
-        self, mapping: dict[str, Any], indent: int
-    ) -> list[tuple[int, str]]:
+    def _format_nested_mapping(self, mapping: dict[str, Any], indent: int) -> list[tuple[int, str]]:
         """Format nested dictionary values."""
         nested_lines: list[tuple[int, str]] = []
         for raw_key, value in mapping.items():
@@ -2133,9 +2029,7 @@ class RichStreamRenderer:
             nested_lines.extend(self._format_nested_entry(key, value, indent))
         return nested_lines
 
-    def _format_sequence_entries(
-        self, sequence: list[Any], indent: int
-    ) -> list[tuple[int, str]]:
+    def _format_sequence_entries(self, sequence: list[Any], indent: int) -> list[tuple[int, str]]:
         """Format list/tuple/set values with YAML-style bullets."""
         if not sequence:
             return []
@@ -2158,18 +2052,14 @@ class RichStreamRenderer:
             return [(indent, f"- {formatted}")]
         return []
 
-    def _format_dict_sequence_item(
-        self, mapping: dict[str, Any], indent: int
-    ) -> list[tuple[int, str]]:
+    def _format_dict_sequence_item(self, mapping: dict[str, Any], indent: int) -> list[tuple[int, str]]:
         """Format a dictionary entry within a list."""
         child_lines = self._format_nested_mapping(mapping, indent + 1)
         if child_lines:
             return self._prepend_sequence_prefix(child_lines, indent)
         return [(indent, "- {}")]
 
-    def _format_nested_sequence_item(
-        self, sequence: list[Any], indent: int
-    ) -> list[tuple[int, str]]:
+    def _format_nested_sequence_item(self, sequence: list[Any], indent: int) -> list[tuple[int, str]]:
         """Format a nested sequence entry within a list."""
         child_lines = self._format_sequence_entries(sequence, indent + 1)
         if child_lines:
@@ -2177,9 +2067,7 @@ class RichStreamRenderer:
         return [(indent, "- []")]
 
     @staticmethod
-    def _prepend_sequence_prefix(
-        child_lines: list[tuple[int, str]], indent: int
-    ) -> list[tuple[int, str]]:
+    def _prepend_sequence_prefix(child_lines: list[tuple[int, str]], indent: int) -> list[tuple[int, str]]:
         """Attach a sequence bullet to the first child line."""
         _, first_text = child_lines[0]
         prefixed: list[tuple[int, str]] = [(indent, f"- {first_text}")]
@@ -2239,9 +2127,7 @@ class RichStreamRenderer:
 
         return Group(*renderables)
 
-    def _update_final_duration(
-        self, duration: float | None, *, overwrite: bool = False
-    ) -> None:
+    def _update_final_duration(self, duration: float | None, *, overwrite: bool = False) -> None:
         """Store formatted duration for eventual final panels."""
         if duration is None:
             return
@@ -2275,12 +2161,7 @@ class RichStreamRenderer:
     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"
-            )
+            return self.OUTPUT_PREFIX + "```json\n" + json.dumps(output_value, indent=2) + "\n```\n"
         except Exception:
             return self.OUTPUT_PREFIX + str(output_value) + "\n"
 
@@ -2304,12 +2185,7 @@ class RichStreamRenderer:
         """Format string that looks like JSON."""
         try:
             parsed = json.loads(output)
-            return (
-                self.OUTPUT_PREFIX
-                + "```json\n"
-                + json.dumps(parsed, indent=2)
-                + "\n```\n"
-            )
+            return self.OUTPUT_PREFIX + "```json\n" + json.dumps(parsed, indent=2) + "\n```\n"
         except Exception:
             return self.OUTPUT_PREFIX + output + "\n"
 
@@ -2319,9 +2195,7 @@ class RichStreamRenderer:
         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("]")
-        ):
+        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"
@@ -2335,7 +2209,7 @@ class RichStreamRenderer:
 
     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):
+        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)

glaip_sdk/utils/rendering/renderer/debug.py

@@ -34,16 +34,10 @@ def _coerce_datetime(value: Any) -> datetime | None:
     return None
 
 
-def _parse_event_timestamp(
-    event: dict[str, Any], received_ts: datetime | None = None
-) -> datetime | None:
+def _parse_event_timestamp(event: dict[str, Any], received_ts: datetime | None = None) -> datetime | None:
     """Resolve the most accurate timestamp available for the event."""
     if received_ts is not None:
-        return (
-            received_ts
-            if received_ts.tzinfo
-            else received_ts.replace(tzinfo=timezone.utc)
-        )
+        return received_ts if received_ts.tzinfo else received_ts.replace(tzinfo=timezone.utc)
 
     ts_value = event.get("timestamp") or (event.get("metadata") or {}).get("timestamp")
     return _coerce_datetime(ts_value)
@@ -86,9 +80,7 @@ def _get_event_metadata(event: dict[str, Any]) -> tuple[str, str | None]:
     return sse_kind, status_str
 
 
-def _build_debug_title(
-    sse_kind: str, status_str: str | None, ts_ms: str, rel: float
-) -> str:
+def _build_debug_title(sse_kind: str, status_str: str | None, ts_ms: str, rel: float) -> str:
     """Build the debug event title."""
     if status_str:
         return f"SSE: {sse_kind} — {status_str} @ {ts_ms} (+{rel:.2f}s)"
@@ -104,9 +96,7 @@ def _dejson_value(obj: Any) -> Any:
         return [_dejson_value(x) for x in obj]
     if isinstance(obj, str):
         s = obj.strip()
-        if (s.startswith("{") and s.endswith("}")) or (
-            s.startswith("[") and s.endswith("]")
-        ):
+        if (s.startswith("{") and s.endswith("}")) or (s.startswith("[") and s.endswith("]")):
             try:
                 return _dejson_value(json.loads(s))
             except Exception:

glaip_sdk/utils/rendering/renderer/panels.py

@@ -128,9 +128,7 @@ def create_context_panel(
     )
 
 
-def create_final_panel(
-    content: str, title: str = "Final Result", theme: str = "dark"
-) -> AIPPanel:
+def create_final_panel(content: str, title: str = "Final Result", theme: str = "dark") -> AIPPanel:
     """Create a final result panel.
 
     Args: