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

glaip_sdk/cli/commands/agents.py

@@ -83,6 +83,7 @@ from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.utils import format_datetime, is_uuid
 from glaip_sdk.utils.agent_config import normalize_agent_config_for_import
 from glaip_sdk.utils.import_export import convert_export_to_import_format
+from glaip_sdk.utils.rendering.renderer.toggle import TranscriptToggleController
 from glaip_sdk.utils.validation import coerce_timeout
 
 console = Console()
@@ -598,6 +599,23 @@ def _setup_run_renderer(ctx: Any, save: str | None, verbose: bool) -> Any:
     )
 
 
+def _maybe_attach_transcript_toggle(ctx: Any, renderer: Any) -> None:
+    """Attach transcript toggle controller when interactive TTY is available."""
+    if renderer is None:
+        return
+
+    console_obj = getattr(renderer, "console", None)
+    if console_obj is None or not getattr(console_obj, "is_terminal", False):
+        return
+
+    tty_enabled = bool(get_ctx_value(ctx, "tty", True))
+    if not tty_enabled:
+        return
+
+    controller = TranscriptToggleController(enabled=True)
+    renderer.transcript_controller = controller
+
+
 def _prepare_run_kwargs(
     agent: Any,
     final_input_text: str,
@@ -733,6 +751,7 @@ def run(
 
         parsed_chat_history = _parse_chat_history(chat_history)
         renderer, working_console = _setup_run_renderer(ctx, save, verbose)
+        _maybe_attach_transcript_toggle(ctx, renderer)
 
         try:
             client.timeout = float(timeout)

glaip_sdk/cli/commands/mcps.py

@@ -1126,8 +1126,7 @@ def update(
         )
         if not import_file and not cli_flags_provided:
             raise click.ClickException(
-                "No update fields specified. Use --import file or at least one of: "
-                "--name, --transport, --description, --config, --auth"
+                "No update fields specified. Use --import or one of: --name, --transport, --description, --config, --auth"
             )
 
         # Resolve MCP using helper function

glaip_sdk/cli/slash/session.py

@@ -958,14 +958,11 @@ class SlashSession:
         keybar = AIPGrid(expand=True)
         keybar.add_column(justify="left", ratio=1)
         keybar.add_column(justify="left", ratio=1)
-        keybar.add_column(justify="left", ratio=1)
-        keybar.add_column(justify="left", ratio=1)
 
         keybar.add_row(
             format_command_hint("/help", "Show commands") or "",
             format_command_hint("/details", "Agent config") or "",
             format_command_hint("/exit", "Back") or "",
-            "[bold]Alt+Enter[/bold] [dim]Line break[/dim]",
         )
 
         return keybar

glaip_sdk/cli/transcript/viewer.py

@@ -27,12 +27,18 @@ except Exception:  # pragma: no cover - optional dependency
 from glaip_sdk.cli.transcript.cache import suggest_filename
 from glaip_sdk.icons import ICON_DELEGATE, ICON_TOOL_STEP
 from glaip_sdk.rich_components import AIPPanel
+from glaip_sdk.utils.rendering.formatting import (
+    build_connector_prefix,
+    glyph_for_status,
+    normalise_display_label,
+)
 from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
 from glaip_sdk.utils.rendering.renderer.panels import create_final_panel
 from glaip_sdk.utils.rendering.renderer.progress import (
     format_elapsed_time,
     is_delegation_tool,
 )
+from glaip_sdk.utils.rendering.steps import StepManager
 
 EXPORT_CANCELLED_MESSAGE = "[dim]Export cancelled.[/dim]"
 
@@ -372,12 +378,13 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         self.console.print()
 
     def _render_steps_summary(self) -> None:
-        panel_content = self._format_steps_summary(self._build_step_summary())
-        panel = AIPPanel(
-            Text(panel_content, style="dim"),
-            title="Steps",
-            border_style="blue",
-        )
+        tree_text = self._build_tree_summary_text()
+        if tree_text is not None:
+            body = tree_text
+        else:
+            panel_content = self._format_steps_summary(self._build_step_summary())
+            body = Text(panel_content, style="dim")
+        panel = AIPPanel(body, title="Steps", border_style="blue")
         self.console.print(panel)
         self.console.print()
 
@@ -460,6 +467,169 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
         return [steps[name] for name in order]
 
+    def _build_tree_summary_text(self) -> Text | None:
+        """Render hierarchical tree from captured SSE events when available."""
+        manager = StepManager()
+        processed = False
+
+        for event in self.ctx.events:
+            payload = self._coerce_step_event(event)
+            if not payload:
+                continue
+            try:
+                manager.apply_event(payload)
+                processed = True
+            except ValueError:
+                continue
+
+        if not processed or not manager.order:
+            return None
+
+        lines: list[str] = []
+        roots = manager.order
+        total_roots = len(roots)
+        for index, root_id in enumerate(roots):
+            self._render_tree_branch(
+                manager=manager,
+                step_id=root_id,
+                ancestor_state=(),
+                is_last=index == total_roots - 1,
+                lines=lines,
+            )
+
+        if not lines:
+            return None
+
+        return Text("\n".join(lines), style="dim")
+
+    def _render_tree_branch(
+        self,
+        *,
+        manager: StepManager,
+        step_id: str,
+        ancestor_state: tuple[bool, ...],
+        is_last: bool,
+        lines: list[str],
+    ) -> None:
+        step = manager.by_id.get(step_id)
+        if not step:
+            return
+
+        suppress = self._should_hide_step(step)
+        children = manager.children.get(step_id, [])
+
+        if not suppress:
+            branch_state = ancestor_state
+            if branch_state:
+                branch_state = branch_state + (is_last,)
+            lines.append(self._format_tree_line(step, branch_state))
+            next_ancestor_state = ancestor_state + (is_last,)
+        else:
+            next_ancestor_state = ancestor_state
+
+        if not children:
+            return
+
+        total_children = len(children)
+        for idx, child_id in enumerate(children):
+            self._render_tree_branch(
+                manager=manager,
+                step_id=child_id,
+                ancestor_state=next_ancestor_state if not suppress else ancestor_state,
+                is_last=idx == total_children - 1,
+                lines=lines,
+            )
+
+    def _should_hide_step(self, step: Any) -> bool:
+        if getattr(step, "parent_id", None) is not None:
+            return False
+        if getattr(step, "kind", None) == "thinking":
+            return True
+        if getattr(step, "kind", None) == "agent":
+            return True
+        name = getattr(step, "name", "") or ""
+        return self._looks_like_uuid(name)
+
+    def _coerce_step_event(self, event: dict[str, Any]) -> dict[str, Any] | None:
+        metadata = event.get("metadata")
+        if not isinstance(metadata, dict):
+            return None
+        if not isinstance(metadata.get("step_id"), str):
+            return None
+        return {
+            "metadata": metadata,
+            "status": event.get("status"),
+            "task_state": event.get("task_state"),
+            "content": event.get("content"),
+            "task_id": event.get("task_id"),
+            "context_id": event.get("context_id"),
+        }
+
+    def _format_tree_line(self, step: Any, branch_state: tuple[bool, ...]) -> str:
+        prefix = build_connector_prefix(branch_state)
+        raw_label = normalise_display_label(getattr(step, "display_label", None))
+        title, summary = self._split_label(raw_label)
+        line = f"{prefix}{title}"
+
+        if summary:
+            line += f" — {self._truncate_summary(summary)}"
+
+        badge = self._format_duration_badge(step)
+        if badge:
+            line += f" {badge}"
+
+        glyph = glyph_for_status(getattr(step, "status_icon", None))
+        failure_reason = getattr(step, "failure_reason", None)
+        if glyph and glyph != "spinner":
+            if failure_reason and glyph == "✗":
+                line += f" {glyph} {failure_reason}"
+            else:
+                line += f" {glyph}"
+        elif failure_reason:
+            line += f" ✗ {failure_reason}"
+
+        return line
+
+    @staticmethod
+    def _format_duration_badge(step: Any) -> str | None:
+        duration_ms = getattr(step, "duration_ms", None)
+        if duration_ms is None:
+            return None
+        try:
+            duration_ms = int(duration_ms)
+        except Exception:
+            return None
+
+        if duration_ms <= 0:
+            payload = "<1ms"
+        elif duration_ms >= 1000:
+            payload = f"{duration_ms / 1000:.2f}s"
+        else:
+            payload = f"{duration_ms}ms"
+
+        return f"[{payload}]"
+
+    @staticmethod
+    def _split_label(label: str) -> tuple[str, str | None]:
+        if " — " in label:
+            title, summary = label.split(" — ", 1)
+            return title.strip(), summary.strip()
+        return label.strip(), None
+
+    @staticmethod
+    def _truncate_summary(summary: str, limit: int = 48) -> str:
+        summary = summary.strip()
+        if len(summary) <= limit:
+            return summary
+        return summary[: limit - 1].rstrip() + "…"
+
+    @staticmethod
+    def _looks_like_uuid(value: str) -> bool:
+        stripped = value.replace("-", "")
+        if len(stripped) not in {32, 36}:
+            return False
+        return all(ch in "0123456789abcdefABCDEF" for ch in stripped)
+
     @staticmethod
     def _format_duration_from_ms(value: Any) -> str | None:
         try:

glaip_sdk/cli/utils.py

@@ -982,7 +982,6 @@ def build_renderer(
         theme=theme,
         style=style,
         live=live_enabled,
-        show_delegate_tool_panels=False,
         append_finished_snapshots=bool(snapshots)
         if snapshots is not None
         else RendererConfig.append_finished_snapshots,

glaip_sdk/client/run_rendering.py

@@ -23,6 +23,58 @@ from glaip_sdk.utils.rendering.renderer import RichStreamRenderer
 from glaip_sdk.utils.rendering.renderer.config import RendererConfig
 
 
+def _coerce_to_string(value: Any) -> str:
+    """Return a best-effort string representation for transcripts."""
+    try:
+        return str(value)
+    except Exception:
+        return f"{value}"
+
+
+def _has_visible_text(value: Any) -> bool:
+    """Return True when the value is a non-empty string."""
+    return isinstance(value, str) and bool(value.strip())
+
+
+def _update_state_transcript(state: Any, text_value: str) -> bool:
+    """Inject transcript text into renderer state if possible."""
+    if state is None:
+        return False
+
+    updated = False
+
+    if hasattr(state, "final_text") and not _has_visible_text(
+        getattr(state, "final_text", "")
+    ):
+        try:
+            state.final_text = text_value
+            updated = True
+        except Exception:
+            pass
+
+    buffer = getattr(state, "buffer", None)
+    if isinstance(buffer, list) and not any(_has_visible_text(item) for item in buffer):
+        buffer.append(text_value)
+        updated = True
+
+    return updated
+
+
+def _update_renderer_transcript(renderer: Any, text_value: str) -> None:
+    """Populate the renderer (or its state) with the supplied text."""
+    state = getattr(renderer, "state", None)
+    if _update_state_transcript(state, text_value):
+        return
+
+    if hasattr(renderer, "final_text") and not _has_visible_text(
+        getattr(renderer, "final_text", "")
+    ):
+        try:
+            setattr(renderer, "final_text", text_value)
+        except Exception:
+            pass
+
+
 class AgentRunRenderingManager:
     """Coordinate renderer creation and streaming event handling."""
 
@@ -79,7 +131,6 @@ class AgentRunRenderingManager:
         silent_config = RendererConfig(
             live=False,
             persist_live=False,
-            show_delegate_tool_panels=False,
             render_thinking=False,
         )
         return RichStreamRenderer(
@@ -92,7 +143,6 @@ class AgentRunRenderingManager:
         minimal_config = RendererConfig(
             live=False,
             persist_live=False,
-            show_delegate_tool_panels=False,
             render_thinking=False,
         )
         return RichStreamRenderer(
@@ -106,7 +156,6 @@ class AgentRunRenderingManager:
             theme="dark",
             style="debug",
             live=False,
-            show_delegate_tool_panels=False,
             append_finished_snapshots=False,
         )
         return RichStreamRenderer(
@@ -139,17 +188,28 @@ class AgentRunRenderingManager:
 
         self._capture_request_id(stream_response, meta, renderer)
 
-        for event in iter_sse_events(stream_response, timeout_seconds, agent_name):
-            if started_monotonic is None:
-                started_monotonic = self._maybe_start_timer(event)
+        controller = getattr(renderer, "transcript_controller", None)
+        if controller and getattr(controller, "enabled", False):
+            controller.on_stream_start(renderer)
 
-            final_text, stats_usage = self._process_single_event(
-                event,
-                renderer,
-                final_text,
-                stats_usage,
-                meta,
-            )
+        try:
+            for event in iter_sse_events(stream_response, timeout_seconds, agent_name):
+                if started_monotonic is None:
+                    started_monotonic = self._maybe_start_timer(event)
+
+                final_text, stats_usage = self._process_single_event(
+                    event,
+                    renderer,
+                    final_text,
+                    stats_usage,
+                    meta,
+                )
+
+                if controller and getattr(controller, "enabled", False):
+                    controller.poll(renderer)
+        finally:
+            if controller and getattr(controller, "enabled", False):
+                controller.on_stream_complete()
 
         finished_monotonic = monotonic()
         return final_text, stats_usage, started_monotonic, finished_monotonic
@@ -194,19 +254,50 @@ class AgentRunRenderingManager:
         kind = (ev.get("metadata") or {}).get("kind")
         renderer.on_event(ev)
 
+        handled = self._handle_metadata_kind(
+            kind,
+            ev,
+            final_text,
+            stats_usage,
+            meta,
+            renderer,
+        )
+        if handled is not None:
+            return handled
+
+        if ev.get("content"):
+            final_text = self._handle_content_event(ev, final_text)
+
+        return final_text, stats_usage
+
+    def _handle_metadata_kind(
+        self,
+        kind: str | None,
+        ev: dict[str, Any],
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        renderer: RichStreamRenderer,
+    ) -> tuple[str, dict[str, Any]] | None:
+        """Process well-known metadata kinds and return updated state."""
         if kind == "artifact":
             return final_text, stats_usage
 
-        if kind == "final_response" and ev.get("content"):
-            final_text = ev.get("content", "")
-        elif ev.get("content"):
-            final_text = self._handle_content_event(ev, final_text)
-        elif kind == "usage":
+        if kind == "final_response":
+            content = ev.get("content")
+            if content:
+                return content, stats_usage
+            return final_text, stats_usage
+
+        if kind == "usage":
             stats_usage.update(ev.get("usage") or {})
-        elif kind == "run_info":
+            return final_text, stats_usage
+
+        if kind == "run_info":
             self._handle_run_info_event(ev, meta, renderer)
+            return final_text, stats_usage
 
-        return final_text, stats_usage
+        return None
 
     def _handle_content_event(self, ev: dict[str, Any], final_text: str) -> str:
         content = ev.get("content", "")
@@ -227,6 +318,16 @@ class AgentRunRenderingManager:
             meta["run_id"] = ev["run_id"]
             renderer.on_start(meta)
 
+    def _ensure_renderer_final_content(
+        self, renderer: RichStreamRenderer, text: str
+    ) -> None:
+        """Populate renderer state with final output when the stream omits it."""
+        if not text:
+            return
+
+        text_value = _coerce_to_string(text)
+        _update_renderer_transcript(renderer, text_value)
+
     # --------------------------------------------------------------------- #
     # Finalisation helpers
     # --------------------------------------------------------------------- #
@@ -258,6 +359,10 @@ class AgentRunRenderingManager:
             except TypeError:
                 rendered_text = ""
 
+        fallback_text = final_text or rendered_text
+        if fallback_text:
+            self._ensure_renderer_final_content(renderer, fallback_text)
+
         renderer.on_complete(st)
         return final_text or rendered_text or "No response content received."
 

glaip_sdk/icons.py

@@ -5,10 +5,13 @@ Authors:
 """
 
 ICON_AGENT = "🤖"
-ICON_AGENT_STEP = "🧠"
+ICON_AGENT_STEP = "🤖"
 ICON_TOOL = "🔧"
-ICON_TOOL_STEP = "⚙️"
-ICON_DELEGATE = ICON_AGENT
+ICON_TOOL_STEP = "🔧"
+ICON_DELEGATE = ICON_AGENT_STEP
+ICON_STATUS_SUCCESS = "✓"
+ICON_STATUS_FAILED = "✗"
+ICON_STATUS_WARNING = "⚠"
 
 __all__ = [
     "ICON_AGENT",
@@ -16,4 +19,7 @@ __all__ = [
     "ICON_TOOL",
     "ICON_TOOL_STEP",
     "ICON_DELEGATE",
+    "ICON_STATUS_SUCCESS",
+    "ICON_STATUS_FAILED",
+    "ICON_STATUS_WARNING",
 ]

glaip_sdk/utils/rendering/formatting.py

@@ -12,7 +12,14 @@ import time
 from collections.abc import Callable
 from typing import Any
 
-from glaip_sdk.icons import ICON_AGENT_STEP, ICON_DELEGATE, ICON_TOOL_STEP
+from glaip_sdk.icons import (
+    ICON_AGENT_STEP,
+    ICON_DELEGATE,
+    ICON_STATUS_FAILED,
+    ICON_STATUS_SUCCESS,
+    ICON_STATUS_WARNING,
+    ICON_TOOL_STEP,
+)
 
 # Constants for argument formatting
 DEFAULT_ARGS_MAX_LEN = 100
@@ -37,9 +44,20 @@ SECRET_VALUE_PATTERNS = [
     re.compile(r"eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+"),  # JWT tokens
 ]
 SENSITIVE_PATTERNS = re.compile(
-    r"password\s*[:=]\s*[^\s,}]+|secret\s*[:=]\s*[^\s,}]+|token\s*[:=]\s*[^\s,}]+|key\s*[:=]\s*[^\s,}]+|api_key\s*[:=]\s*[^\s,}]+|^password$|^secret$|^token$|^key$|^api_key$",
+    r"(?:password|secret|token|key|api_key)(?:\s*[:=]\s*[^\s,}]+)?",
     re.IGNORECASE,
 )
+CONNECTOR_VERTICAL = "│   "
+CONNECTOR_EMPTY = "    "
+CONNECTOR_BRANCH = "├─ "
+CONNECTOR_LAST = "└─ "
+ROOT_MARKER = ""
+SECRET_MASK = "••••••"
+STATUS_GLYPHS = {
+    "success": ICON_STATUS_SUCCESS,
+    "failed": ICON_STATUS_FAILED,
+    "warning": ICON_STATUS_WARNING,
+}
 
 
 def _truncate_string(s: str, max_len: int) -> str:
@@ -53,7 +71,7 @@ def mask_secrets_in_string(text: str) -> str:
     """Mask sensitive information in a string."""
     result = text
     for pattern in SECRET_VALUE_PATTERNS:
-        result = re.sub(pattern, "••••••", result)
+        result = re.sub(pattern, SECRET_MASK, result)
     return result
 
 
@@ -74,7 +92,7 @@ def _redact_dict_values(text: dict) -> dict:
     result = {}
     for key, value in text.items():
         if _is_sensitive_key(key):
-            result[key] = "••••••"
+            result[key] = SECRET_MASK
         elif _should_recurse_redaction(value):
             result[key] = redact_sensitive(value)
         else:
@@ -92,11 +110,11 @@ def _redact_string_content(text: str) -> str:
     result = text
     # First mask secrets
     for pattern in SECRET_VALUE_PATTERNS:
-        result = re.sub(pattern, "••••••", result)
+        result = re.sub(pattern, SECRET_MASK, result)
     # Then redact sensitive patterns
     result = re.sub(
         SENSITIVE_PATTERNS,
-        lambda m: m.group(0).split("=")[0] + "=••••••",
+        lambda m: m.group(0).split("=")[0] + "=" + SECRET_MASK,
         result,
     )
     return result
@@ -116,6 +134,31 @@ def _should_recurse_redaction(value: Any) -> bool:
     return isinstance(value, dict | list) or isinstance(value, str)
 
 
+def glyph_for_status(icon_key: str | None) -> str | None:
+    """Return glyph representing a step status icon key."""
+    if not icon_key:
+        return None
+    return STATUS_GLYPHS.get(icon_key)
+
+
+def normalise_display_label(label: str | None) -> str:
+    """Return a user facing label or the Unknown fallback."""
+    label = (label or "").strip()
+    return label or "Unknown step detail"
+
+
+def build_connector_prefix(branch_state: tuple[bool, ...]) -> str:
+    """Build connector prefix for a tree line based on ancestry state."""
+    if not branch_state:
+        return ROOT_MARKER
+
+    parts: list[str] = []
+    for ancestor_is_last in branch_state[:-1]:
+        parts.append(CONNECTOR_EMPTY if ancestor_is_last else CONNECTOR_VERTICAL)
+    parts.append(CONNECTOR_LAST if branch_state[-1] else CONNECTOR_BRANCH)
+    return "".join(parts)
+
+
 def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     """Format arguments in a pretty way."""
     if not args:
@@ -132,7 +175,7 @@ def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     try:
         args_str = json.dumps(masked_args, ensure_ascii=False, separators=(",", ":"))
         return _truncate_string(args_str, max_len)
-    except (TypeError, ValueError, Exception):
+    except Exception:
         # Fallback to string representation if JSON serialization fails
         args_str = str(masked_args)
         return _truncate_string(args_str, max_len)

glaip_sdk/utils/rendering/models.py

@@ -30,19 +30,32 @@ class Step:
     context_id: str | None = None
     started_at: float = field(default_factory=monotonic)
     duration_ms: int | None = None
-
-    def finish(self, duration_raw: float | None) -> None:
+    duration_source: str | None = None
+    display_label: str | None = None
+    status_icon: str | None = None
+    failure_reason: str | None = None
+    branch_failed: bool = False
+    is_parallel: bool = False
+    server_started_at: float | None = None
+    server_finished_at: float | None = None
+    duration_unknown: bool = False
+
+    def finish(self, duration_raw: float | None, *, source: str | None = None) -> None:
         """Mark the step as finished and calculate duration.
 
         Args:
             duration_raw: Raw duration in seconds, or None to calculate from started_at
+            source: Optional duration source tag
         """
+        self.duration_unknown = False
         if isinstance(duration_raw, int | float) and duration_raw > 0:
             # Use provided duration if it's a positive number (even if very small)
             self.duration_ms = round(float(duration_raw) * 1000)
+            self.duration_source = source or self.duration_source or "provided"
         else:
             # Calculate from started_at if duration_raw is None, negative, or zero
             self.duration_ms = int((monotonic() - self.started_at) * 1000)
+            self.duration_source = source or self.duration_source or "monotonic"
         self.status = "finished"
 
 

glaip_sdk/utils/rendering/renderer/__init__.py

@@ -35,7 +35,6 @@ def make_silent_renderer() -> RichStreamRenderer:
     cfg = RendererConfig(
         live=False,
         persist_live=False,
-        show_delegate_tool_panels=False,
         render_thinking=False,
     )
     return RichStreamRenderer(
@@ -51,7 +50,6 @@ def make_minimal_renderer() -> RichStreamRenderer:
     cfg = RendererConfig(
         live=False,
         persist_live=False,
-        show_delegate_tool_panels=False,
         render_thinking=False,
     )
     return RichStreamRenderer(console=Console(), cfg=cfg)