glaip-sdk 0.0.20__py3-none-any.whl → 0.1.3__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/config.py

@@ -13,21 +13,15 @@ from dataclasses import dataclass
 class RendererConfig:
     """Configuration for the RichStreamRenderer."""
 
-    # Style and layout
-    theme: str = "dark"  # dark|light
-    style: str = "pretty"  # pretty|debug|minimal
-
     # Performance
-    think_threshold: float = 0.7
     refresh_debounce: float = 0.25
     render_thinking: bool = True
     live: bool = True
     persist_live: bool = True
-
-    # Debug visibility toggles
-    show_delegate_tool_panels: bool = False
+    summary_display_window: int = 20
 
     # Scrollback/append options
+    summary_max_steps: int = 0
     append_finished_snapshots: bool = False
-    snapshot_max_chars: int = 12000
-    snapshot_max_lines: int = 200
+    snapshot_max_chars: int = 0
+    snapshot_max_lines: int = 0

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:

glaip_sdk/utils/rendering/renderer/progress.py

@@ -48,15 +48,11 @@ def format_working_indicator(
     """Format a working indicator with elapsed time."""
     base_message = "Working..."
 
-    if started_at is None and (
-        server_elapsed_time is None or streaming_started_at is None
-    ):
+    if started_at is None and (server_elapsed_time is None or streaming_started_at is None):
         return base_message
 
     spinner_chip = f"{get_spinner_char()} {base_message}"
-    elapsed = _resolve_elapsed_time(
-        started_at, server_elapsed_time, streaming_started_at
-    )
+    elapsed = _resolve_elapsed_time(started_at, server_elapsed_time, streaming_started_at)
     if elapsed is None:
         return spinner_chip
 
@@ -93,11 +89,7 @@ def is_delegation_tool(tool_name: str) -> bool:
     Returns:
         True if this is a delegation tool
     """
-    return (
-        tool_name.startswith("delegate_to_")
-        or tool_name.startswith("delegate_")
-        or "sub_agent" in tool_name.lower()
-    )
+    return tool_name.startswith("delegate_to_") or tool_name.startswith("delegate_") or "sub_agent" in tool_name.lower()
 
 
 def _delegation_tool_title(tool_name: str) -> str | None:

glaip_sdk/utils/rendering/renderer/stream.py

@@ -38,27 +38,25 @@ class StreamProcessor:
         Returns:
             Dictionary with extracted metadata
         """
-        metadata = event.get("metadata", {})
+        metadata = event.get("metadata") or {}
         # Update server elapsed timing if backend provides it
         try:
             t = metadata.get("time")
-            if isinstance(t, int | float):
+            if isinstance(t, (int, float)):
                 self.server_elapsed_time = float(t)
         except Exception:
             pass
 
         return {
             "kind": metadata.get("kind") if metadata else event.get("kind"),
-            "task_id": event.get("task_id"),
-            "context_id": event.get("context_id"),
+            "task_id": metadata.get("task_id") or event.get("task_id"),
+            "context_id": metadata.get("context_id") or event.get("context_id"),
             "content": event.get("content", ""),
             "status": metadata.get("status") if metadata else event.get("status"),
             "metadata": metadata,
         }
 
-    def _extract_metadata_tool_calls(
-        self, metadata: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_metadata_tool_calls(self, metadata: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from metadata."""
         tool_calls = metadata.get("tool_calls", [])
         if not tool_calls:
@@ -84,9 +82,7 @@ class StreamProcessor:
 
         return tool_name, tool_args, tool_out, tool_calls_info
 
-    def _extract_tool_info_calls(
-        self, tool_info: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_tool_info_calls(self, tool_info: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from tool_info structure."""
         tool_calls_info = []
         tool_name = None
@@ -98,9 +94,7 @@ class StreamProcessor:
         if isinstance(ti_calls, list) and ti_calls:
             for call in ti_calls:
                 if isinstance(call, dict) and call.get("name"):
-                    tool_calls_info.append(
-                        (call.get("name"), call.get("args", {}), call.get("output"))
-                    )
+                    tool_calls_info.append((call.get("name"), call.get("args", {}), call.get("output")))
             if tool_calls_info:
                 tool_name, tool_args, tool_out = tool_calls_info[0]
             return tool_name, tool_args, tool_out, tool_calls_info
@@ -114,9 +108,7 @@ class StreamProcessor:
 
         return tool_name, tool_args, tool_out, tool_calls_info
 
-    def _extract_tool_calls_from_metadata(
-        self, metadata: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_tool_calls_from_metadata(self, metadata: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from metadata structure."""
         tool_info = metadata.get("tool_info", {}) or {}
 
@@ -125,9 +117,7 @@ class StreamProcessor:
 
         return None, {}, None, []
 
-    def parse_tool_calls(
-        self, event: dict[str, Any]
-    ) -> tuple[str | None, Any, Any, list[tuple[str, Any, Any]]]:
+    def parse_tool_calls(self, event: dict[str, Any]) -> tuple[str | None, Any, Any, list[tuple[str, Any, Any]]]:
         """Parse tool call information from an event.
 
         Args:
@@ -166,29 +156,6 @@ class StreamProcessor:
         if context_id:
             self.last_event_time_by_ctx[context_id] = monotonic()
 
-    def should_insert_thinking_gap(
-        self, task_id: str | None, context_id: str | None, think_threshold: float
-    ) -> bool:
-        """Determine if a thinking gap should be inserted.
-
-        Args:
-            task_id: Task identifier
-            context_id: Context identifier
-            think_threshold: Threshold for thinking gap
-
-        Returns:
-            True if thinking gap should be inserted
-        """
-        if not task_id or not context_id:
-            return False
-
-        last_time = self.last_event_time_by_ctx.get(context_id)
-        if last_time is None:
-            return True
-
-        elapsed = monotonic() - last_time
-        return elapsed >= think_threshold
-
     def track_tools_and_agents(
         self,
         tool_name: str | None,

glaip_sdk/utils/rendering/renderer/summary_window.py

@@ -0,0 +1,79 @@
+"""Helpers for clamping the steps summary view to a rolling window.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from rich.text import Text
+
+Node = tuple[str, tuple[bool, ...]]
+LabelFn = Callable[[str], str]
+ParentFn = Callable[[str], str | None]
+
+
+def clamp_step_nodes(
+    nodes: list[Node],
+    *,
+    window: int,
+    get_label: LabelFn,
+    get_parent: ParentFn,
+) -> tuple[list[Node], Text | None, Text | None]:
+    """Return a windowed slice of nodes plus optional header/footer notices."""
+    if window <= 0 or len(nodes) <= window:
+        return nodes, None, None
+
+    start_index = len(nodes) - window
+    first_visible_step_id = nodes[start_index][0]
+    header = _build_header(first_visible_step_id, window, len(nodes), get_label, get_parent)
+    footer = _build_footer(len(nodes) - window)
+    return nodes[start_index:], header, footer
+
+
+def _build_header(
+    step_id: str,
+    window: int,
+    total: int,
+    get_label: LabelFn,
+    get_parent: ParentFn,
+) -> Text:
+    """Construct the leading notice for a truncated window."""
+    parts = [f"… (latest {window} of {total} steps shown"]
+    path = _collect_path_labels(step_id, get_label, get_parent)
+    if path:
+        parts.append("; continuing with ")
+        parts.append(" / ".join(path))
+    parts.append(")")
+    return Text("".join(parts), style="dim")
+
+
+def _build_footer(hidden_count: int) -> Text:
+    """Construct the footer notice indicating hidden steps."""
+    noun = "step" if hidden_count == 1 else "steps"
+    message = f"{hidden_count} earlier {noun} hidden. Press Ctrl+T to inspect the full transcript."
+    return Text(message, style="dim")
+
+
+def _collect_path_labels(
+    step_id: str,
+    get_label: LabelFn,
+    get_parent: ParentFn,
+) -> list[str]:
+    """Collect labels for the ancestry of the provided step."""
+    labels: list[str] = []
+    seen: set[str] = set()
+    current = step_id
+    while current and current not in seen:
+        seen.add(current)
+        label = get_label(current)
+        if label:
+            labels.append(label)
+        parent = get_parent(current)
+        if not parent:
+            break
+        current = parent
+    labels.reverse()
+    return labels

glaip_sdk/utils/rendering/renderer/toggle.py

@@ -0,0 +1,182 @@
+"""Keyboard-driven transcript toggling support for the live renderer.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from typing import Any
+
+try:  # pragma: no cover - Windows-specific dependencies
+    import msvcrt  # type: ignore[import]
+except ImportError:  # pragma: no cover - POSIX fallback
+    msvcrt = None  # type: ignore[assignment]
+
+if os.name != "nt":  # pragma: no cover - POSIX-only imports
+    import select
+    import termios
+    import tty
+
+
+CTRL_T = "\x14"
+
+
+class TranscriptToggleController:
+    """Manage mid-run transcript toggling for RichStreamRenderer instances."""
+
+    def __init__(self, *, enabled: bool) -> None:
+        """Initialise controller.
+
+        Args:
+            enabled: Whether toggling should be active (usually gated by TTY checks).
+        """
+        self._enabled = enabled and bool(sys.stdin) and sys.stdin.isatty()
+        self._lock = threading.Lock()
+        self._posix_fd: int | None = None
+        self._posix_attrs: list[int] | None = None
+        self._active = False
+        self._stop_event = threading.Event()
+        self._poll_thread: threading.Thread | None = None
+
+    @property
+    def enabled(self) -> bool:
+        """Return True when controller is able to process keypresses."""
+        return self._enabled
+
+    def on_stream_start(self, renderer: Any) -> None:
+        """Prepare terminal state before streaming begins."""
+        if not self._enabled:
+            return
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._active = True
+            self._start_polling_thread(renderer)
+            return
+
+        fd = sys.stdin.fileno()
+        try:
+            attrs = termios.tcgetattr(fd)
+        except Exception:
+            self._enabled = False
+            return
+
+        try:
+            tty.setcbreak(fd)
+        except Exception:
+            try:
+                termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+            except Exception:
+                pass
+            self._enabled = False
+            return
+
+        with self._lock:
+            self._posix_fd = fd
+            self._posix_attrs = attrs
+            self._active = True
+
+        self._start_polling_thread(renderer)
+
+    def on_stream_complete(self) -> None:
+        """Restore terminal state when streaming ends."""
+        if not self._active:
+            return
+
+        self._stop_polling_thread()
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._active = False
+            return
+
+        with self._lock:
+            fd = self._posix_fd
+            attrs = self._posix_attrs
+            self._posix_fd = None
+            self._posix_attrs = None
+            self._active = False
+
+        if fd is None or attrs is None:
+            return
+
+        try:
+            termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+        except Exception:
+            pass
+
+    def poll(self, renderer: Any) -> None:
+        """Poll for toggle keypresses and update renderer if needed."""
+        if not self._active:
+            return
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._poll_windows(renderer)
+        else:
+            self._poll_posix(renderer)
+
+    # ------------------------------------------------------------------
+    # Platform-specific polling
+    # ------------------------------------------------------------------
+    def _poll_windows(self, renderer: Any) -> None:
+        if not msvcrt:  # pragma: no cover - safety guard
+            return
+
+        while msvcrt.kbhit():
+            ch = msvcrt.getwch()
+            if ch == CTRL_T:
+                renderer.toggle_transcript_mode()
+
+    def _poll_posix(self, renderer: Any) -> None:  # pragma: no cover - requires TTY
+        fd = self._posix_fd
+        if fd is None:
+            return
+
+        while True:
+            readable, _, _ = select.select([fd], [], [], 0)
+            if not readable:
+                return
+
+            try:
+                data = os.read(fd, 1)
+            except Exception:
+                return
+
+            if not data:
+                return
+
+            ch = data.decode(errors="ignore")
+            if ch == CTRL_T:
+                renderer.toggle_transcript_mode()
+
+    def _start_polling_thread(self, renderer: Any) -> None:
+        if self._poll_thread and self._poll_thread.is_alive():
+            return
+        if not self._active:
+            return
+
+        self._stop_event.clear()
+        self._poll_thread = threading.Thread(target=self._poll_loop, args=(renderer,), daemon=True)
+        self._poll_thread.start()
+
+    def _stop_polling_thread(self) -> None:
+        self._stop_event.set()
+        thread = self._poll_thread
+        if thread and thread.is_alive():
+            thread.join(timeout=0.2)
+        self._poll_thread = None
+
+    def _poll_loop(self, renderer: Any) -> None:
+        while self._active and not self._stop_event.is_set():
+            try:
+                if os.name == "nt":
+                    self._poll_windows(renderer)
+                else:
+                    self._poll_posix(renderer)
+            except Exception:
+                # Never let background polling disrupt the main stream
+                pass
+            time.sleep(0.05)

glaip_sdk/utils/rendering/step_tree_state.py

@@ -0,0 +1,100 @@
+"""State container for hierarchical renderer steps.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+
+from glaip_sdk.utils.rendering.models import Step
+
+
+@dataclass(slots=True)
+class StepTreeState:
+    """Track hierarchical ordering, buffers, and pruning metadata."""
+
+    max_steps: int = 200
+    root_order: list[str] = field(default_factory=list)
+    child_map: dict[str, list[str]] = field(default_factory=dict)
+    buffered_children: dict[str, list[str]] = field(default_factory=dict)
+    running_by_context: dict[tuple[str | None, str | None], set[str]] = field(default_factory=dict)
+    retained_ids: set[str] = field(default_factory=set)
+    step_index: dict[str, Step] = field(default_factory=dict)
+    pending_branch_failures: set[str] = field(default_factory=set)
+
+    def link_root(self, step_id: str) -> None:
+        """Ensure a step id is present in the root ordering."""
+        if step_id not in self.root_order:
+            self.root_order.append(step_id)
+
+    def unlink_root(self, step_id: str) -> None:
+        """Remove a step id from the root ordering if present."""
+        if step_id in self.root_order:
+            self.root_order.remove(step_id)
+
+    def link_child(self, parent_id: str, child_id: str) -> None:
+        """Attach a child step to a parent."""
+        children = self.child_map.setdefault(parent_id, [])
+        if child_id not in children:
+            children.append(child_id)
+
+    def unlink_child(self, parent_id: str, child_id: str) -> None:
+        """Detach a child from a parent."""
+        children = self.child_map.get(parent_id)
+        if not children:
+            return
+
+        if child_id in children:
+            children.remove(child_id)
+        # Clean up if the list is now empty
+        if len(children) == 0:
+            self.child_map.pop(parent_id, None)
+
+    def buffer_child(self, parent_id: str, child_id: str) -> None:
+        """Track a child that is waiting for its parent to appear."""
+        queue = self.buffered_children.setdefault(parent_id, [])
+        if child_id not in queue:
+            queue.append(child_id)
+
+    def pop_buffered_children(self, parent_id: str) -> list[str]:
+        """Return any buffered children for a parent."""
+        return self.buffered_children.pop(parent_id, [])
+
+    def discard_running(self, step_id: str) -> None:
+        """Remove a step from running context tracking."""
+        for key, running in tuple(self.running_by_context.items()):
+            if step_id in running:
+                running.discard(step_id)
+                if not running:
+                    self.running_by_context.pop(key, None)
+
+    def iter_visible_tree(self) -> Iterator[tuple[str, tuple[bool, ...]]]:
+        """Yield step ids in depth-first order alongside branch metadata.
+
+        Returns:
+            Iterator of (step_id, branch_state) tuples where branch_state
+            captures whether each ancestor was the last child. This data
+            is later used by rendering helpers to draw connectors such as
+            `│`, `├─`, and `└─` consistently.
+        """
+        roots = tuple(self.root_order)
+        total_roots = len(roots)
+        for index, root_id in enumerate(roots):
+            yield root_id, ()
+            ancestor_state = (index == total_roots - 1,)
+            yield from self._walk_children(root_id, ancestor_state)
+
+    def _walk_children(
+        self, parent_id: str, ancestor_state: tuple[bool, ...]
+    ) -> Iterator[tuple[str, tuple[bool, ...]]]:
+        """Depth-first traversal helper yielding children with ancestry info."""
+        children = self.child_map.get(parent_id, [])
+        total_children = len(children)
+        for idx, child_id in enumerate(children):
+            is_last = idx == total_children - 1
+            branch_state = ancestor_state + (is_last,)
+            yield child_id, branch_state
+            yield from self._walk_children(child_id, branch_state)