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

glaip_sdk/client/validators.py

@@ -39,9 +39,7 @@ class ResourceValidator:
         if len(found_tools) == 1:
             return str(found_tools[0].id)
         elif len(found_tools) > 1:
-            raise AmbiguousResourceError(
-                f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}"
-            )
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}")
         else:
             raise NotFoundError(f"Tool not found: {tool_name}")
 
@@ -51,9 +49,7 @@ class ResourceValidator:
         if len(found_tools) == 1:
             return str(found_tools[0].id)
         elif len(found_tools) > 1:
-            raise AmbiguousResourceError(
-                f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}"
-            )
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}")
         else:
             raise NotFoundError(f"Tool not found: {tool.name}")
 
@@ -73,9 +69,7 @@ class ResourceValidator:
         elif hasattr(tool, "name") and tool.name is not None:
             return self._resolve_tool_by_name_attribute(tool, client)
         else:
-            raise ValidationError(
-                f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute"
-            )
+            raise ValidationError(f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute")
 
     def _process_single_tool(self, tool: str | Tool, client: Any) -> str:
         """Process a single tool reference and return its ID."""
@@ -99,22 +93,14 @@ class ResourceValidator:
             try:
                 tool_id = cls()._process_single_tool(tool, client)
                 tool_ids.append(tool_id)
-            except (AmbiguousResourceError, NotFoundError) as e:
+            except (AmbiguousResourceError, NotFoundError) as err:
                 # Determine the tool name for the error message
-                tool_name = (
-                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
-                )
-                raise ValidationError(
-                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
-                )
-            except Exception as e:
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
+            except Exception as err:
                 # For other exceptions, wrap them appropriately
-                tool_name = (
-                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
-                )
-                raise ValidationError(
-                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
-                )
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
 
         return tool_ids
 
@@ -158,9 +144,7 @@ class ResourceValidator:
         elif hasattr(agent, "name") and agent.name is not None:
             return self._resolve_agent_by_name_attribute(agent, client)
         else:
-            raise ValidationError(
-                f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute"
-            )
+            raise ValidationError(f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute")
 
     def _process_single_agent(self, agent: str | Any, client: Any) -> str:
         """Process a single agent reference and return its ID."""
@@ -184,26 +168,14 @@ class ResourceValidator:
             try:
                 agent_id = cls()._process_single_agent(agent, client)
                 agent_ids.append(agent_id)
-            except (AmbiguousResourceError, NotFoundError) as e:
+            except (AmbiguousResourceError, NotFoundError) as err:
                 # Determine the agent name for the error message
-                agent_name = (
-                    agent
-                    if isinstance(agent, str)
-                    else getattr(agent, "name", str(agent))
-                )
-                raise ValidationError(
-                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
-                )
-            except Exception as e:
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
+            except Exception as err:
                 # For other exceptions, wrap them appropriately
-                agent_name = (
-                    agent
-                    if isinstance(agent, str)
-                    else getattr(agent, "name", str(agent))
-                )
-                raise ValidationError(
-                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
-                )
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
 
         return agent_ids
 
@@ -213,8 +185,8 @@ class ResourceValidator:
         for tool_id in tool_ids:
             try:
                 client.get_tool_by_id(tool_id)
-            except NotFoundError:
-                raise ValidationError(f"Tool not found: {tool_id}")
+            except NotFoundError as err:
+                raise ValidationError(f"Tool not found: {tool_id}") from err
 
     @classmethod
     def validate_agents_exist(cls, agent_ids: list[str], client: Any) -> None:
@@ -222,5 +194,5 @@ class ResourceValidator:
         for agent_id in agent_ids:
             try:
                 client.get_agent_by_id(agent_id)
-            except NotFoundError:
-                raise ValidationError(f"Agent not found: {agent_id}")
+            except NotFoundError as err:
+                raise ValidationError(f"Agent not found: {agent_id}") from err

glaip_sdk/exceptions.py

@@ -107,9 +107,7 @@ class AgentTimeoutError(TimeoutError):
             agent_name: Optional name of the agent that timed out
         """
         agent_info = f" for agent '{agent_name}'" if agent_name else ""
-        message = (
-            f"Agent execution timed out after {timeout_seconds} seconds{agent_info}"
-        )
+        message = f"Agent execution timed out after {timeout_seconds} seconds{agent_info}"
         super().__init__(message)
         self.timeout_seconds = timeout_seconds
         self.agent_name = agent_name

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/models.py

@@ -13,6 +13,9 @@ from pydantic import BaseModel
 
 from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 
+_AGENT_CLIENT_REQUIRED_MSG = "No client available. Use client.get_agent_by_id() to get a client-connected agent."
+_MCP_CLIENT_REQUIRED_MSG = "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
+
 
 class Agent(BaseModel):
     """Agent model for API responses."""
@@ -27,9 +30,7 @@ class Agent(BaseModel):
     tools: list[dict[str, Any]] | None = None  # Backend returns ToolReference objects
     agents: list[dict[str, Any]] | None = None  # Backend returns AgentReference objects
     mcps: list[dict[str, Any]] | None = None  # Backend returns MCPReference objects
-    tool_configs: dict[str, Any] | None = (
-        None  # Backend returns tool configurations keyed by tool UUID
-    )
+    tool_configs: dict[str, Any] | None = None  # Backend returns tool configurations keyed by tool UUID
     agent_config: dict[str, Any] | None = None
     timeout: int = DEFAULT_AGENT_RUN_TIMEOUT
     metadata: dict[str, Any] | None = None
@@ -53,9 +54,7 @@ class Agent(BaseModel):
             **kwargs: Additional arguments passed to run_agent
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         # 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
@@ -80,9 +79,7 @@ class Agent(BaseModel):
             Exception: For other unexpected errors
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         # Automatically pass the agent name for better context
         kwargs.setdefault("agent_name", self.name)
         # Pass the agent's configured timeout if not explicitly overridden
@@ -95,9 +92,7 @@ class Agent(BaseModel):
     def update(self, **kwargs) -> "Agent":
         """Update agent attributes."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         updated_agent = self._client.update_agent(self.id, **kwargs)
         # Update current instance with new data
         for key, value in updated_agent.model_dump().items():
@@ -108,9 +103,7 @@ class Agent(BaseModel):
     def delete(self) -> None:
         """Delete the agent."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         self._client.delete_agent(self.id)
 
 
@@ -149,16 +142,12 @@ class Tool(BaseModel):
         Pass 'file' parameter to update tool code via file upload.
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_tool_by_id() to get a client-connected tool."
-            )
+            raise RuntimeError("No client available. Use client.get_tool_by_id() to get a client-connected tool.")
 
         # Check if file upload is requested
         if "file" in kwargs:
             file_path = kwargs.pop("file")  # Remove file from kwargs for metadata
-            updated_tool = self._client.tools.update_tool_via_file(
-                self.id, file_path, **kwargs
-            )
+            updated_tool = self._client.tools.update_tool_via_file(self.id, file_path, **kwargs)
         else:
             # Regular metadata update
             updated_tool = self._client.tools.update_tool(self.id, **kwargs)
@@ -172,9 +161,7 @@ class Tool(BaseModel):
     def delete(self) -> None:
         """Delete the tool."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_tool_by_id() to get a client-connected tool."
-            )
+            raise RuntimeError("No client available. Use client.get_tool_by_id() to get a client-connected tool.")
         self._client.delete_tool(self.id)
 
 
@@ -198,9 +185,7 @@ class MCP(BaseModel):
     def get_tools(self) -> list[dict[str, Any]]:
         """Get tools available from this MCP."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError(_MCP_CLIENT_REQUIRED_MSG)
         # This would delegate to the client's MCP tools endpoint
         # For now, return empty list as placeholder
         return []
@@ -208,9 +193,7 @@ class MCP(BaseModel):
     def update(self, **kwargs) -> "MCP":
         """Update MCP attributes."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError(_MCP_CLIENT_REQUIRED_MSG)
         updated_mcp = self._client.update_mcp(self.id, **kwargs)
         # Update current instance with new data
         for key, value in updated_mcp.model_dump().items():
@@ -221,9 +204,7 @@ class MCP(BaseModel):
     def delete(self) -> None:
         """Delete the MCP."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError("No client available. Use client.get_mcp_by_id() to get a client-connected MCP.")
         self._client.delete_mcp(self.id)
 
 

glaip_sdk/payload_schemas/agent.py

@@ -60,9 +60,7 @@ AGENT_FIELD_RULES: Mapping[str, FieldRule] = {
 }
 
 
-def get_import_field_plan(
-    field_name: str, operation: AgentImportOperation
-) -> ImportFieldPlan:
+def get_import_field_plan(field_name: str, operation: AgentImportOperation) -> ImportFieldPlan:
     """Return the import handling plan for ``field_name`` under ``operation``.
 
     Unknown fields default to being copied as-is so new API fields propagate

glaip_sdk/utils/agent_config.py

@@ -54,17 +54,11 @@ def sanitize_agent_config(
         cfg = agent_config or {}
 
     if strip_lm_identity and isinstance(cfg, dict):
-        cfg = {
-            k: v
-            for k, v in cfg.items()
-            if k not in {"lm_provider", "lm_name", "lm_base_url"}
-        }
+        cfg = {k: v for k, v in cfg.items() if k not in {"lm_provider", "lm_name", "lm_base_url"}}
     return cfg
 
 
-def resolve_language_model_selection(
-    merged_data: dict[str, Any], cli_model: str | None
-) -> tuple[dict[str, Any], bool]:
+def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str | None) -> tuple[dict[str, Any], bool]:
     """Resolve language model selection from merged data and CLI args.
 
     Implements the LM selection priority:
@@ -98,17 +92,13 @@ def resolve_language_model_selection(
     # Priority 3: Legacy lm_name from agent_config
     agent_config = merged_data.get("agent_config") or {}
     if isinstance(agent_config, dict) and agent_config.get("lm_name"):
-        return {
-            "model": agent_config["lm_name"]
-        }, True  # Strip LM identity when extracting from agent_config
+        return {"model": agent_config["lm_name"]}, True  # Strip LM identity when extracting from agent_config
 
     # No LM selection found
     return {}, False
 
 
-def normalize_agent_config_for_import(
-    agent_data: dict[str, Any], cli_model: str | None = None
-) -> dict[str, Any]:
+def normalize_agent_config_for_import(agent_data: dict[str, Any], cli_model: str | None = None) -> dict[str, Any]:
     """Automatically normalize agent configuration by extracting LM settings from agent_config.
 
     This function addresses the common issue where exported agent configurations contain

glaip_sdk/utils/client_utils.py

@@ -90,9 +90,7 @@ def extract_ids(items: list[str | Any] | None) -> list[str] | None:
     return result if result else None
 
 
-def create_model_instances(
-    data: list[dict] | None, model_class: type, client: Any
-) -> list[Any]:
+def create_model_instances(data: list[dict] | None, model_class: type, client: Any) -> list[Any]:
     """Create model instances from API data with client association.
 
     This is a common pattern used across different clients (agents, tools, mcps)
@@ -112,9 +110,7 @@ def create_model_instances(
     return [model_class(**item_data)._set_client(client) for item_data in data]
 
 
-def find_by_name(
-    items: list[Any], name: str, case_sensitive: bool = False
-) -> list[Any]:
+def find_by_name(items: list[Any], name: str, case_sensitive: bool = False) -> list[Any]:
     """Filter items by name with optional case sensitivity.
 
     This is a common pattern used across different clients for client-side
@@ -234,9 +230,7 @@ def _handle_streaming_error(
     if isinstance(e, httpx.ReadTimeout):
         logger.error(f"Read timeout during streaming: {e}")
         logger.error("This usually indicates the backend is taking too long to respond")
-        logger.error(
-            "Consider increasing the timeout value or checking backend performance"
-        )
+        logger.error("Consider increasing the timeout value or checking backend performance")
         raise AgentTimeoutError(timeout_seconds or 30.0, agent_name)
 
     elif isinstance(e, httpx.TimeoutException):
@@ -275,9 +269,7 @@ def _yield_event_data(event_data: dict[str, Any] | None) -> Iterator[dict[str, A
         yield event_data
 
 
-def _flush_remaining_buffer(
-    buf: list[str], event_type: str | None, event_id: str | None
-) -> Iterator[dict[str, Any]]:
+def _flush_remaining_buffer(buf: list[str], event_type: str | None, event_id: str | None) -> Iterator[dict[str, Any]]:
     """Flush any remaining data in buffer."""
     if buf:
         yield {
@@ -317,9 +309,7 @@ def iter_sse_events(
             if line is None:
                 continue
 
-            buf, event_type, event_id, event_data, completed = _process_sse_line(
-                line, buf, event_type, event_id
-            )
+            buf, event_type, event_id, event_data, completed = _process_sse_line(line, buf, event_type, event_id)
 
             yield from _yield_event_data(event_data)
             if completed:
@@ -385,9 +375,7 @@ def _create_form_data(message: str) -> dict[str, Any]:
     return {"input": message, "message": message, "stream": True}
 
 
-def _prepare_file_entry(
-    item: str | BinaryIO, stack: ExitStack
-) -> tuple[str, tuple[str, BinaryIO, str]]:
+def _prepare_file_entry(item: str | BinaryIO, stack: ExitStack) -> tuple[str, tuple[str, BinaryIO, str]]:
     """Prepare a single file entry for multipart data."""
     if isinstance(item, str):
         return _prepare_path_entry(item, stack)
@@ -395,9 +383,7 @@ def _prepare_file_entry(
         return _prepare_stream_entry(item)
 
 
-def _prepare_path_entry(
-    path_str: str, stack: ExitStack
-) -> tuple[str, tuple[str, BinaryIO, str]]:
+def _prepare_path_entry(path_str: str, stack: ExitStack) -> tuple[str, tuple[str, BinaryIO, str]]:
     """Prepare a file path entry."""
     file_path = Path(path_str)
     if not file_path.exists():

glaip_sdk/utils/display.py

@@ -109,9 +109,7 @@ def print_agent_updated(agent: Any) -> None:
     """
     if RICH_AVAILABLE:
         console = _create_console()
-        console.print(
-            f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' updated successfully[/]"
-        )
+        console.print(f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' updated successfully[/]")
     else:
         print(f"✅ Agent '{agent.name}' updated successfully")
 
@@ -124,8 +122,6 @@ def print_agent_deleted(agent_id: str) -> None:
     """
     if RICH_AVAILABLE:
         console = _create_console()
-        console.print(
-            f"[{SUCCESS_STYLE}]✅ Agent deleted successfully (ID: {agent_id})[/]"
-        )
+        console.print(f"[{SUCCESS_STYLE}]✅ Agent deleted successfully (ID: {agent_id})[/]")
     else:
         print(f"✅ Agent deleted successfully (ID: {agent_id})")

glaip_sdk/utils/general.py

@@ -76,9 +76,7 @@ def format_datetime(dt: datetime | str | None) -> str:
     return str(dt)
 
 
-def progress_bar(
-    iterable: Iterable[Any], description: str = "Processing"
-) -> Iterator[Any]:
+def progress_bar(iterable: Iterable[Any], description: str = "Processing") -> Iterator[Any]:
     """Simple progress bar using click.
 
     Args:

glaip_sdk/utils/import_export.py

@@ -71,14 +71,10 @@ def _get_default_array_fields() -> list[str]:
 
 def _should_use_cli_value(cli_value: Any) -> bool:
     """Check if CLI value should be used."""
-    return cli_value is not None and (
-        not isinstance(cli_value, list | tuple) or len(cli_value) > 0
-    )
+    return cli_value is not None and (not isinstance(cli_value, (list, tuple)) or len(cli_value) > 0)
 
 
-def _handle_array_field_merge(
-    key: str, cli_value: Any, import_data: dict[str, Any]
-) -> Any:
+def _handle_array_field_merge(key: str, cli_value: Any, import_data: dict[str, Any]) -> Any:
     """Handle merging of array fields."""
     import_value = import_data[key]
     if isinstance(import_value, list):
@@ -107,9 +103,7 @@ def _merge_cli_values_with_import(
             merged[key] = import_data[key]
 
 
-def _add_import_only_fields(
-    merged: dict[str, Any], import_data: dict[str, Any]
-) -> None:
+def _add_import_only_fields(merged: dict[str, Any], import_data: dict[str, Any]) -> None:
     """Add fields that exist only in import data."""
     for key, import_value in import_data.items():
         if key not in merged:

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
@@ -105,15 +123,37 @@ def _redact_string_content(text: str) -> str:
 def _is_sensitive_key(key: str) -> bool:
     """Check if a key contains sensitive information."""
     key_lower = key.lower()
-    return any(
-        sensitive in key_lower
-        for sensitive in ["password", "secret", "token", "key", "api_key"]
-    )
+    return any(sensitive in key_lower for sensitive in ["password", "secret", "token", "key", "api_key"])
 
 
 def _should_recurse_redaction(value: Any) -> bool:
     """Check if a value should be recursively processed."""
-    return isinstance(value, dict | list) or isinstance(value, str)
+    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:
@@ -132,7 +172,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
         """
-        if isinstance(duration_raw, int | float) and duration_raw > 0:
+        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"
 
 
@@ -68,8 +81,4 @@ class RunStats:
         Returns:
             Duration in seconds if run is finished, None otherwise
         """
-        return (
-            None
-            if self.finished_at is None
-            else round(self.finished_at - self.started_at, 2)
-        )
+        return None if self.finished_at is None else round(self.finished_at - self.started_at, 2)

glaip_sdk/utils/rendering/renderer/__init__.py

@@ -35,12 +35,9 @@ def make_silent_renderer() -> RichStreamRenderer:
     cfg = RendererConfig(
         live=False,
         persist_live=False,
-        show_delegate_tool_panels=False,
         render_thinking=False,
     )
-    return RichStreamRenderer(
-        console=Console(file=io.StringIO(), force_terminal=False), cfg=cfg
-    )
+    return RichStreamRenderer(console=Console(file=io.StringIO(), force_terminal=False), cfg=cfg)
 
 
 def make_minimal_renderer() -> RichStreamRenderer:
@@ -51,7 +48,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)