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

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=True,
             append_finished_snapshots=False,
         )
         return RichStreamRenderer(
@@ -118,7 +167,7 @@ class AgentRunRenderingManager:
     def _create_default_renderer(self, verbose: bool) -> RichStreamRenderer:
         if verbose:
             return self._create_verbose_renderer()
-        default_config = RendererConfig(show_delegate_tool_panels=True)
+        default_config = RendererConfig()
         return RichStreamRenderer(console=_Console(), cfg=default_config)
 
     # --------------------------------------------------------------------- #
@@ -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

@@ -0,0 +1,25 @@
+"""Lightweight icon definitions used across the CLI.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+ICON_AGENT = "🤖"
+ICON_AGENT_STEP = "🤖"
+ICON_TOOL = "🔧"
+ICON_TOOL_STEP = "🔧"
+ICON_DELEGATE = ICON_AGENT_STEP
+ICON_STATUS_SUCCESS = "✓"
+ICON_STATUS_FAILED = "✗"
+ICON_STATUS_WARNING = "⚠"
+
+__all__ = [
+    "ICON_AGENT",
+    "ICON_AGENT_STEP",
+    "ICON_TOOL",
+    "ICON_TOOL_STEP",
+    "ICON_DELEGATE",
+    "ICON_STATUS_SUCCESS",
+    "ICON_STATUS_FAILED",
+    "ICON_STATUS_WARNING",
+]

glaip_sdk/models.py

@@ -58,6 +58,9 @@ class Agent(BaseModel):
             )
         # Automatically pass the agent name for better renderer display
         kwargs.setdefault("agent_name", self.name)
+        # Pass the agent's configured timeout if not explicitly overridden
+        if "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
         # Pass verbose flag through to enable event JSON output
         return self._client.run_agent(self.id, message, verbose=verbose, **kwargs)
 
@@ -82,6 +85,9 @@ class Agent(BaseModel):
             )
         # Automatically pass the agent name for better context
         kwargs.setdefault("agent_name", self.name)
+        # Pass the agent's configured timeout if not explicitly overridden
+        if "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
 
         async for chunk in self._client.arun_agent(self.id, message, **kwargs):
             yield chunk

glaip_sdk/rich_components.py

@@ -38,4 +38,32 @@ class AIPTable(Table):
         super().__init__(*args, **kwargs)
 
 
-__all__ = ["AIPPanel", "AIPTable"]
+class AIPGrid(Table):
+    """Table-based grid with GL AIP defaults for layout blocks."""
+
+    def __init__(
+        self,
+        *,
+        expand: bool = True,
+        padding: tuple[int, int] = (0, 1),
+        collapse_padding: bool = True,
+    ):
+        """Initialize AIPGrid with zero-edge borders and optional expansion.
+
+        Args:
+            expand: Whether the grid should expand to fill available width.
+            padding: Cell padding for the grid (row, column).
+            collapse_padding: Collapse padding between renderables.
+        """
+        super().__init__(
+            show_header=False,
+            show_edge=False,
+            pad_edge=False,
+            box=None,
+            expand=expand,
+            padding=padding,
+            collapse_padding=collapse_padding,
+        )
+
+
+__all__ = ["AIPPanel", "AIPTable", "AIPGrid"]

glaip_sdk/utils/__init__.py

@@ -5,6 +5,7 @@ Authors:
 """
 
 from glaip_sdk.utils.display import (
+    RICH_AVAILABLE,
     print_agent_created,
     print_agent_deleted,
     print_agent_output,
@@ -19,7 +20,6 @@ from glaip_sdk.utils.general import (
 )
 from glaip_sdk.utils.rendering.models import RunStats, Step
 from glaip_sdk.utils.rendering.steps import StepManager
-from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
 from glaip_sdk.utils.run_renderer import RichStreamRenderer
 
 __all__ = [

glaip_sdk/utils/client_utils.py

@@ -17,6 +17,12 @@ from typing import Any, BinaryIO, NoReturn
 import httpx
 
 from glaip_sdk.exceptions import AgentTimeoutError
+from glaip_sdk.utils.resource_refs import (
+    extract_ids as extract_ids_new,
+)
+from glaip_sdk.utils.resource_refs import (
+    find_by_name as find_by_name_new,
+)
 
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.client_utils")
@@ -77,8 +83,6 @@ def extract_ids(items: list[str | Any] | None) -> list[str] | None:
         This function maintains backward compatibility by returning None for empty input.
         New code should use glaip_sdk.utils.resource_refs.extract_ids which returns [].
     """
-    from .resource_refs import extract_ids as extract_ids_new
-
     if not items:
         return None
 
@@ -127,8 +131,6 @@ def find_by_name(
     Note:
         This function now delegates to glaip_sdk.utils.resource_refs.find_by_name.
     """
-    from .resource_refs import find_by_name as find_by_name_new
-
     return find_by_name_new(items, name, case_sensitive)
 
 

glaip_sdk/utils/display.py

@@ -4,9 +4,51 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
+from glaip_sdk.branding import SUCCESS, SUCCESS_STYLE
+from glaip_sdk.icons import ICON_AGENT
+
+if TYPE_CHECKING:  # pragma: no cover - import-time typing helpers
+    from rich.console import Console
+    from rich.text import Text
+
+    from glaip_sdk.rich_components import AIPPanel
+
+
+def _check_rich_available() -> bool:
+    """Check if Rich and our custom components can be imported."""
+    try:
+        __import__("rich.console")
+        __import__("rich.text")
+        __import__("glaip_sdk.rich_components")
+        return True
+    except Exception:
+        return False
+
+
+RICH_AVAILABLE = _check_rich_available()
+
+
+def _create_console() -> "Console":
+    """Return a Console instance with lazy import to ease mocking."""
+    from rich.console import Console  # Local import for test friendliness
+
+    return Console()
+
+
+def _create_text(*args: Any, **kwargs: Any) -> "Text":
+    """Return a Text instance with lazy import to ease mocking."""
+    from rich.text import Text  # Local import for test friendliness
+
+    return Text(*args, **kwargs)
+
+
+def _create_panel(*args: Any, **kwargs: Any) -> "AIPPanel":
+    """Return an AIPPanel instance with lazy import to ease mocking."""
+    from glaip_sdk.rich_components import AIPPanel  # Local import for test friendliness
+
+    return AIPPanel(*args, **kwargs)
 
 
 def print_agent_output(output: str, title: str = "Agent Output") -> None:
@@ -17,17 +59,11 @@ def print_agent_output(output: str, title: str = "Agent Output") -> None:
         title: Title for the output panel
     """
     if RICH_AVAILABLE:
-        # Lazy import Rich components
-        from rich.console import Console
-        from rich.text import Text
-
-        from glaip_sdk.rich_components import AIPPanel
-
-        console = Console()
-        panel = AIPPanel(
-            Text(output, style="green"),
+        console = _create_console()
+        panel = _create_panel(
+            _create_text(output, style=SUCCESS),
             title=title,
-            border_style="green",
+            border_style=SUCCESS,
         )
         console.print(panel)
     else:
@@ -36,7 +72,7 @@ def print_agent_output(output: str, title: str = "Agent Output") -> None:
         print("=" * (len(title) + 8))
 
 
-def print_agent_created(agent: Any, title: str = "🤖 Agent Created") -> None:
+def print_agent_created(agent: Any, title: str = f"{ICON_AGENT} Agent Created") -> None:
     """Print agent creation success with rich formatting.
 
     Args:
@@ -44,21 +80,16 @@ def print_agent_created(agent: Any, title: str = "🤖 Agent Created") -> None:
         title: Title for the output panel
     """
     if RICH_AVAILABLE:
-        # Lazy import Rich components
-        from rich.console import Console
-
-        from glaip_sdk.rich_components import AIPPanel
-
-        console = Console()
-        panel = AIPPanel(
-            f"[green]✅ Agent '{agent.name}' created successfully![/green]\n\n"
+        console = _create_console()
+        panel = _create_panel(
+            f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' created successfully![/]\n\n"
             f"ID: {agent.id}\n"
             f"Model: {getattr(agent, 'model', 'N/A')}\n"
             f"Type: {getattr(agent, 'type', 'config')}\n"
             f"Framework: {getattr(agent, 'framework', 'langchain')}\n"
             f"Version: {getattr(agent, 'version', '1.0')}",
             title=title,
-            border_style="green",
+            border_style=SUCCESS,
         )
         console.print(panel)
     else:
@@ -77,11 +108,10 @@ def print_agent_updated(agent: Any) -> None:
         agent: The updated agent object
     """
     if RICH_AVAILABLE:
-        # Lazy import Rich components
-        from rich.console import Console
-
-        console = Console()
-        console.print(f"[green]✅ Agent '{agent.name}' updated successfully[/green]")
+        console = _create_console()
+        console.print(
+            f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' updated successfully[/]"
+        )
     else:
         print(f"✅ Agent '{agent.name}' updated successfully")
 
@@ -93,10 +123,9 @@ def print_agent_deleted(agent_id: str) -> None:
         agent_id: The deleted agent's ID
     """
     if RICH_AVAILABLE:
-        # Lazy import Rich components
-        from rich.console import Console
-
-        console = Console()
-        console.print(f"[green]✅ Agent deleted successfully (ID: {agent_id})[/green]")
+        console = _create_console()
+        console.print(
+            f"[{SUCCESS_STYLE}]✅ Agent deleted successfully (ID: {agent_id})[/]"
+        )
     else:
         print(f"✅ Agent deleted successfully (ID: {agent_id})")

glaip_sdk/utils/rendering/formatting.py

@@ -6,11 +6,21 @@ Authors:
 
 from __future__ import annotations
 
+import json
 import re
 import time
 from collections.abc import Callable
 from typing import Any
 
+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
 IMPORTANT_PARAMETER_KEYS = [
@@ -34,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:
@@ -50,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
 
 
@@ -71,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:
@@ -89,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
@@ -113,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:
@@ -127,11 +173,9 @@ def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
 
     # Convert to JSON string and truncate if needed
     try:
-        import json
-
         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)
@@ -174,11 +218,11 @@ def get_spinner_char() -> str:
 def get_step_icon(step_kind: str) -> str:
     """Get the appropriate icon for a step kind."""
     if step_kind == "tool":
-        return "⚙️"  # Gear emoji for tool
+        return ICON_TOOL_STEP
     if step_kind == "delegate":
-        return "🤝"  # Handshake for delegate
+        return ICON_DELEGATE
     if step_kind == "agent":
-        return "🧠"  # Brain emoji for agent
+        return ICON_AGENT_STEP
     return ""
 
 

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)