glaip-sdk 0.7.9__py3-none-any.whl → 0.7.11__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -54,6 +54,7 @@ from glaip_sdk.utils.resource_refs import is_uuid
 
 if TYPE_CHECKING:
     from glaip_sdk.client.schedules import AgentScheduleManager
+    from glaip_sdk.guardrails import GuardrailManager
     from glaip_sdk.models import AgentResponse
     from glaip_sdk.registry import AgentRegistry, MCPRegistry, ToolRegistry
 
@@ -130,6 +131,7 @@ class Agent:
         agents: list | None = None,
         mcps: list | None = None,
         model: str | None = _UNSET,  # type: ignore[assignment]
+        guardrail: GuardrailManager | None = None,
         _client: Any = None,
         **kwargs: Any,
     ) -> None:
@@ -147,7 +149,9 @@ class Agent:
             agents: List of sub-agents (Agent classes, instances, or strings).
             mcps: List of MCPs.
             model: Model identifier.
+            guardrail: The guardrail manager for content safety.
             _client: Internal client reference (set automatically).
+
             **kwargs: Additional configuration parameters:
                 - timeout: Execution timeout in seconds.
                 - metadata: Optional metadata dictionary.
@@ -173,6 +177,7 @@ class Agent:
         self._agents = agents
         self._mcps = mcps
         self._model = model
+        self._guardrail = guardrail
         self._language_model_id: str | None = None
         # Extract parameters from kwargs with _UNSET defaults
         self._timeout = kwargs.pop("timeout", Agent._UNSET)  # type: ignore[assignment]
@@ -452,6 +457,11 @@ class Agent:
             return self._mcp_configs
         return None
 
+    @property
+    def guardrail(self) -> GuardrailManager | None:
+        """The guardrail manager for content safety."""
+        return self._guardrail
+
     @property
     def a2a_profile(self) -> dict[str, Any] | None:
         """A2A (Agent-to-Agent) profile configuration.
@@ -547,11 +557,20 @@ class Agent:
 
         # Handle agent_config with timeout
         # The timeout property is a convenience that maps to agent_config.execution_timeout
-        agent_config = dict(self.agent_config) if self.agent_config else {}
+        raw_config = self.agent_config if self.agent_config is not self._UNSET else {}
+        agent_config = dict(raw_config) if raw_config else {}
+
         if self.timeout and "execution_timeout" not in agent_config:
             agent_config["execution_timeout"] = self.timeout
-        if agent_config:
-            config["agent_config"] = agent_config
+
+        if self.guardrail:
+            from glaip_sdk.guardrails.serializer import (  # noqa: PLC0415
+                serialize_guardrail_manager,
+            )
+
+            agent_config["guardrails"] = serialize_guardrail_manager(self.guardrail)
+
+        config["agent_config"] = agent_config
 
         # Handle tool_configs - resolve tool names/classes to IDs
         if self.tool_configs:
@@ -583,11 +602,20 @@ class Agent:
 
         Returns:
             List of resolved MCP IDs for the API payload.
+
+        Raises:
+            ValueError: If an MCP fails to resolve to a valid ID.
         """
         if not self.mcps:
             return []
 
-        return [registry.resolve(mcp_ref).id for mcp_ref in self.mcps]
+        resolved_ids: list[str] = []
+        for mcp_ref in self.mcps:
+            mcp = registry.resolve(mcp_ref)
+            if not mcp.id:
+                raise ValueError(f"Failed to resolve ID for MCP: {mcp_ref}")
+            resolved_ids.append(mcp.id)
+        return resolved_ids
 
     def _resolve_tools(self, registry: ToolRegistry) -> list[str]:
         """Resolve tool references to IDs using ToolRegistry.
@@ -601,12 +629,20 @@ class Agent:
 
         Returns:
             List of resolved tool IDs for the API payload.
+
+        Raises:
+            ValueError: If a tool fails to resolve to a valid ID.
         """
         if not self.tools:
             return []
 
-        # Resolve each tool reference to a Tool object, extract ID
-        return [registry.resolve(tool_ref).id for tool_ref in self.tools]
+        resolved_ids: list[str] = []
+        for tool_ref in self.tools:
+            tool = registry.resolve(tool_ref)
+            if not tool.id:
+                raise ValueError(f"Failed to resolve ID for tool: {tool_ref}")
+            resolved_ids.append(tool.id)
+        return resolved_ids
 
     def _resolve_tool_configs(self, registry: ToolRegistry) -> dict[str, Any]:
         """Resolve tool_configs keys from tool names/classes to tool IDs.
@@ -649,6 +685,8 @@ class Agent:
             try:
                 # Resolve key (tool name/class) to Tool object, get ID
                 tool = registry.resolve(key)
+                if not tool.id:
+                    raise ValueError(f"Resolved tool has no ID: {key}")
                 resolved[tool.id] = config
             except (ValueError, KeyError) as e:
                 raise ValueError(f"Failed to resolve tool config key: {key}") from e
@@ -684,6 +722,8 @@ class Agent:
                     resolved_id = key
                 else:
                     mcp = registry.resolve(key)
+                    if not mcp.id:
+                        raise ValueError(f"Resolved MCP has no ID: {key}")
                     resolved_id = mcp.id
 
                 if resolved_id in resolved:
@@ -699,7 +739,7 @@ class Agent:
 
         return resolved
 
-    def _resolve_agents(self, registry: AgentRegistry) -> list:
+    def _resolve_agents(self, registry: AgentRegistry) -> list[str]:
         """Resolve sub-agent references using AgentRegistry.
 
         Uses the global AgentRegistry to cache Agent objects across deployments.
@@ -711,12 +751,20 @@ class Agent:
 
         Returns:
             List of resolved agent IDs for the API payload.
+
+        Raises:
+            ValueError: If an agent fails to resolve to a valid ID.
         """
         if not self.agents:
             return []
 
-        # Resolve each agent reference to a deployed Agent, extract ID
-        return [registry.resolve(agent_ref).id for agent_ref in self.agents]
+        resolved_ids: list[str] = []
+        for agent_ref in self.agents:
+            agent = registry.resolve(agent_ref)
+            if not agent.id:
+                raise ValueError(f"Failed to resolve ID for agent: {agent_ref}")
+            resolved_ids.append(agent.id)
+        return resolved_ids
 
     def _create_or_update_agent(
         self,
@@ -807,6 +855,8 @@ class Agent:
         Returns:
             Dictionary containing Agent attributes.
         """
+        config = self._build_config(get_tool_registry(), get_mcp_registry())
+
         data = {
             "id": self._id,
             "name": self.name,
@@ -820,10 +870,11 @@ class Agent:
             "mcps": self.mcps,
             "timeout": self.timeout,
             "metadata": self.metadata,
-            "agent_config": self.agent_config,
+            "agent_config": config.get("agent_config"),
             "tool_configs": self.tool_configs,
             "mcp_configs": self.mcp_configs,
             "a2a_profile": self.a2a_profile,
+            "guardrail": self.guardrail,
             "created_at": self._created_at,
             "updated_at": self._updated_at,
         }

glaip_sdk/branding.py

@@ -17,6 +17,7 @@ import platform
 import sys
 
 from rich.console import Console
+from rich.text import Text
 
 from glaip_sdk._version import __version__ as SDK_VERSION
 from glaip_sdk.rich_components import AIPPanel
@@ -110,9 +111,13 @@ GDP Labs AI Agents Package
         return SDK_VERSION
 
     @staticmethod
-    def _make_console() -> Console:
+    def _make_console(force_terminal: bool | None = None, *, soft_wrap: bool = True) -> Console:
         """Create a Rich Console instance respecting NO_COLOR environment variables.
 
+        Args:
+            force_terminal: Override terminal detection when True/False.
+            soft_wrap: Whether to enable soft wrapping in the console.
+
         Returns:
             Console instance with color system configured based on environment.
         """
@@ -124,7 +129,12 @@ GDP Labs AI Agents Package
         else:
             color_system = "auto"
             no_color = False
-        return Console(color_system=color_system, no_color=no_color, soft_wrap=True)
+        return Console(
+            color_system=color_system,
+            no_color=no_color,
+            soft_wrap=soft_wrap,
+            force_terminal=force_terminal,
+        )
 
     # ---- public API -----------------------------------------------------------
     def get_welcome_banner(self) -> str:
@@ -209,3 +219,104 @@ GDP Labs AI Agents Package
             AIPBranding instance
         """
         return cls(version=sdk_version, package_name=package_name)
+
+
+class LogoAnimator:
+    """Animated logo with pulse effect for CLI startup.
+
+    Provides a "Knight Rider" style light pulse animation that sweeps across
+    the GL AIP logo during initialization tasks. Respects NO_COLOR and non-TTY
+    environments with graceful degradation.
+    """
+
+    # Animation colors from GDP Labs brand palette
+    BASE_BLUE = SECONDARY_MEDIUM  # "#005CB8" - Medium Blue
+    HIGHLIGHT = SECONDARY_LIGHT  # "#40B4E5" - Light Blue
+    WHITE = "#FFFFFF"  # Bright white center
+
+    def __init__(self, console: Console | None = None) -> None:
+        """Initialize LogoAnimator.
+
+        Args:
+            console: Optional console instance. If None, creates a default console.
+        """
+        self.console = console or AIPBranding._make_console()
+        self.logo = AIPBranding.AIP_LOGO
+        self.lines = self.logo.split("\n")
+        self.max_width = max(len(line) for line in self.lines) if self.lines else 0
+
+    def generate_frame(self, step: int, status_text: str = "") -> Text:
+        """Generate a single animation frame with logo pulse and status.
+
+        Args:
+            step: Current animation step (position of the pulse).
+            status_text: Optional status text to display below the logo.
+
+        Returns:
+            Text object with styled logo and status.
+        """
+        text = Text()
+
+        for line in self.lines:
+            for x, char in enumerate(line):
+                distance = abs(x - step)
+
+                if distance == 0:
+                    style = f"bold {self.WHITE}"  # Bright white center
+                elif distance <= 3:
+                    style = f"bold {self.HIGHLIGHT}"  # Light blue glow
+                else:
+                    style = self.BASE_BLUE  # Base blue
+
+                text.append(char, style=style)
+            text.append("\n")
+
+        # Add status area below the logo
+        if status_text:
+            text.append(f"\n{status_text}\n")
+
+        return text
+
+    def should_animate(self) -> bool:
+        """Check if animation should be used.
+
+        Returns:
+            True if animation should be used (interactive TTY with colors),
+            False otherwise (NO_COLOR set or non-TTY).
+        """
+        # Check for NO_COLOR environment variables
+        no_color = os.getenv("NO_COLOR") is not None or os.getenv("AIP_NO_COLOR") is not None
+        if no_color:
+            return False
+
+        # Check if console is a TTY
+        if not self.console.is_terminal:
+            return False
+
+        # Check if console explicitly disables colors
+        if self.console.no_color:
+            return False
+
+        # If we get here, we have a TTY without NO_COLOR set
+        # Rich will handle color detection, so we can animate
+        return True
+
+    def display_static_logo(self, status_text: str = "") -> None:
+        """Display static logo without animation (for non-TTY or NO_COLOR).
+
+        Args:
+            status_text: Optional status text to display below the logo.
+        """
+        self.console.print(self.static_frame(status_text))
+
+    def static_frame(self, status_text: str = "") -> Text:
+        """Return a static logo frame for use in non-animated renders.
+
+        Args:
+            status_text: Optional status text to display below the logo.
+        """
+        logo_text = Text(self.logo, style=self.BASE_BLUE)
+        if status_text:
+            logo_text.append("\n")
+            logo_text.append(status_text)
+        return logo_text

glaip_sdk/cli/slash/remote_runs_controller.py

@@ -294,12 +294,14 @@ class RemoteRunsController:
             fetch_detail=fetch_detail,
             export_run=export_run,
         )
+        tui_ctx = getattr(self.session, "tui_ctx", None)
         page, limit, cursor = run_remote_runs_textual(
             runs_page,
             state.get("cursor", 0),
             callbacks,
             agent_name=agent_name,
             agent_id=agent_id,
+            ctx=tui_ctx,
         )
         state["page"] = page
         state["limit"] = limit