glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__py3-none-any.whl

glaip_sdk/agents/component.py

@@ -0,0 +1,233 @@
+"""Agent Component for Glaip SDK.
+
+This module provides the AgentComponent class, which wraps an Agent
+to be used as a reusable component in pipelines.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from gllm_core.schema import Chunk, Component
+from gllm_core.utils import LoggerManager
+
+if TYPE_CHECKING:
+    from glaip_sdk.agents import Agent
+
+logger = LoggerManager().get_logger(__name__)
+
+
+class AgentComponent(Component):
+    """A Component that wraps a GL Agent for pipeline integration.
+
+    This component acts as a bridge between structured pipeline state
+    and the natural language interface of an Agent. It compiles inputs
+    (query, context, history) into a prompt and executes the agent.
+    """
+
+    def __init__(self, agent: Agent) -> None:
+        """Initialize the AgentComponent.
+
+        Args:
+            agent: The Agent instance to wrap.
+        """
+        super().__init__()
+        self.agent = agent
+
+    def _format_context(self, context: list[Chunk | str | dict[str, Any] | Any] | None) -> str:
+        """Format the context list into a string.
+
+        Supports Chunk objects (extracting content), strings, and dicts.
+
+        Args:
+            context: List of context items.
+
+        Returns:
+            Formatted context string.
+        """
+        if not context:
+            return ""
+
+        formatted_items = []
+        for item in context:
+            if isinstance(item, Chunk):
+                content = item.content
+            elif isinstance(item, dict):
+                content = str(item)
+            else:
+                content = str(item)
+            formatted_items.append(f"- {content}")
+
+        return "\n".join(formatted_items)
+
+    def _format_history(self, history: list[Any] | None) -> str:
+        """Format the chat history into a string.
+
+        Supports gllm_inference Message objects and dicts.
+
+        Args:
+            history: List of history items.
+
+        Returns:
+            Formatted history string.
+        """
+        if not history:
+            return "No previous history."
+
+        # Try to use gllm_inference schema if available for robust handling
+        try:
+            from gllm_inference.schema import Message  # noqa: PLC0415
+        except ImportError:
+            Message = None
+
+        formatted_items = []
+        for item in history:
+            if Message and isinstance(item, Message):
+                # Message object has role and contents (list)
+                role = item.role.capitalize()
+                # Use standard content property if available, or join contents
+                content = getattr(item, "content", None)
+                if content is None and hasattr(item, "contents"):
+                    content = "\n".join([str(c) for c in item.contents])
+                formatted_items.append(f"{role}: {content}")
+            elif isinstance(item, dict):
+                role = str(item.get("role", "User")).capitalize()
+                content = str(item.get("content", ""))
+                formatted_items.append(f"{role}: {content}")
+            else:
+                formatted_items.append(str(item))
+        return "\n".join(formatted_items)
+
+    def _compile_prompt(
+        self,
+        query: str,
+        context: list[Any] | None,
+        chat_history: list[Any] | None,
+    ) -> str:
+        """Compile the raw inputs into a single text prompt.
+
+        Args:
+            query: The user query.
+            context: List of context items.
+            chat_history: List of conversation history items.
+
+        Returns:
+            The compiled prompt string.
+        """
+        parts = []
+
+        if chat_history:
+            history_str = self._format_history(chat_history)
+            parts.append(f"Conversation History:\n{history_str}\n")
+
+        if context:
+            context_str = self._format_context(context)
+            parts.append(f"Context:\n{context_str}\n")
+
+        parts.append(f"{query}\n")
+
+        return "\n".join(parts)
+
+    async def run_agent(
+        self,
+        query: str,
+        context: list[Chunk | Any] | None = None,
+        chat_history: list[Any] | None = None,
+        runtime_config: dict[str, Any] | None = None,
+        run_kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Run the agent with the provided context and history.
+
+        This method is the main entry point for the component logic.
+
+        Args:
+            query: The user's input string.
+            context: List of retrieved documents/chunks or data.
+            chat_history: List of previous conversation turns.
+            runtime_config: Optional configuration.
+            run_kwargs: Optional payload for advanced agent execution parameters.
+
+        Returns:
+            The raw response dictionary from the agent.
+        """
+        if not query:
+            raise ValueError("Query is required")
+
+        logger.info("Compiling prompt for agent: %s", self.agent.name)
+
+        prompt = self._compile_prompt(
+            query=query,
+            context=context,
+            chat_history=chat_history,
+        )
+
+        params = (run_kwargs or {}).copy()
+        if runtime_config:
+            params["runtime_config"] = runtime_config
+
+        last_chunk = {}
+
+        try:
+            async for chunk in self.agent.arun(message=prompt, **params):
+                if isinstance(chunk, dict):
+                    last_chunk = chunk
+                    if chunk.get("event_type") == "final_response":
+                        return chunk
+        except Exception as e:
+            raise RuntimeError(f"AgentComponent '{self.agent.name}' failed during execution: {e}") from e
+
+        return last_chunk
+
+    def _extract_content_string(self, result: Any) -> str:
+        """Extract the content string from the agent response.
+
+        Assumes the result is always a string or a dictionary containing a content field.
+
+        Args:
+            result: The agent response (dict or string).
+
+        Returns:
+            The content string extracted from the response.
+        """
+        if isinstance(result, dict):
+            content = result.get("content")
+            if content is not None:
+                return str(content)
+            return str(result)
+
+        return str(result) if result is not None else ""
+
+    async def _run(self, **kwargs: Any) -> str:
+        """Execute the component logic.
+
+        Args:
+            **kwargs: Keyword arguments including query, context, chat_history,
+                        runtime_config, and run_kwargs. All execution control parameters
+                        (e.g., local, verbose, temperature, etc.) must be provided via
+                        run_kwargs dict.
+
+        Returns:
+            The content string extracted from the response.
+        """
+        # Extract standard component inputs
+        query = kwargs.pop("query", None)
+        context = kwargs.pop("context", None)
+        chat_history = kwargs.pop("chat_history", None)
+        runtime_config = kwargs.pop("runtime_config", None)
+        run_kwargs = kwargs.pop("run_kwargs", None)
+
+        # Ignore any remaining unrecognized kwargs for API consistency
+        # All execution parameters must be provided via run_kwargs
+
+        result = await self.run_agent(
+            query=query,  # type: ignore[arg-type]
+            context=context,
+            chat_history=chat_history,
+            runtime_config=runtime_config,
+            run_kwargs=run_kwargs,
+        )
+
+        return self._extract_content_string(result)

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

@@ -523,6 +523,21 @@ class AccountStore:
 
         self._save_config(config)
 
+    def save_config_updates(self, config: dict[str, Any]) -> None:
+        """Save config updates, preserving all existing keys.
+
+        This method allows external code to update arbitrary config keys
+        (e.g., TUI preferences) while preserving the full config structure.
+
+        Args:
+            config: Complete configuration dictionary to save. This should
+                include all keys that should be preserved, not just updates.
+
+        Raises:
+            AccountStoreError: If config file cannot be written.
+        """
+        self._save_config(config)
+
 
 # Global instance for convenience
 _account_store = AccountStore()

glaip_sdk/cli/auth.py

@@ -19,8 +19,7 @@ from rich.console import Console
 
 from glaip_sdk.branding import HINT_PREFIX_STYLE, WARNING_STYLE
 from glaip_sdk.cli.account_store import AccountNotFoundError, AccountStoreError, get_account_store
-from glaip_sdk.cli.hints import format_command_hint
-from glaip_sdk.cli.utils import command_hint
+from glaip_sdk.cli.hints import command_hint, format_command_hint
 
 
 def prepare_authentication_export(
@@ -526,12 +525,19 @@ def resolve_api_url_from_context(
     elif hasattr(ctx, "obj") and isinstance(ctx.obj, dict):
         account_name = ctx.obj.get("account_name")
 
-    resolved_url, _, _ = resolve_credentials(
-        account_name=account_name,
-        api_url=api_url,
-        api_key=None,
-        ignore_env_creds=True,
-    )
+    if isinstance(api_url, str) and api_url.strip():
+        return api_url.strip()
+
+    try:
+        resolved_url, _, _ = resolve_credentials(
+            account_name=account_name,
+            api_url=None,
+            api_key=None,
+            ignore_env_creds=True,
+        )
+    except Exception:
+        return None
+
     return resolved_url
 
 

glaip_sdk/cli/commands/accounts.py

@@ -33,7 +33,7 @@ from glaip_sdk.cli.commands.common_config import check_connection, render_brandi
 from glaip_sdk.cli.hints import format_command_hint
 from glaip_sdk.cli.masking import mask_api_key_display
 from glaip_sdk.cli.slash.accounts_shared import env_credentials_present
-from glaip_sdk.cli.utils import command_hint
+from glaip_sdk.cli.hints import command_hint
 from glaip_sdk.icons import ICON_TOOL
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 

glaip_sdk/cli/commands/agents/__init__.py

@@ -0,0 +1,116 @@
+"""Agent CLI commands package.
+
+This package contains agent management commands split by operation.
+The package is the canonical import surface.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# pylint: disable=duplicate-code
+# Import from submodules
+from glaip_sdk.cli.commands.agents._common import (  # noqa: E402
+    AGENT_NOT_FOUND_ERROR,
+    _coerce_mapping_candidate,
+    _display_agent_details,
+    _emit_verbose_guidance,
+    _fetch_full_agent_details,
+    _get_agent_for_update,
+    _get_agent_model_name,
+    _get_language_model_display_name,
+    _model_from_config,
+    _prepare_agent_output,
+    _resolve_agent,
+    _resolve_resources_by_name,
+    agents_group,
+    console,
+)
+from glaip_sdk.cli.commands.agents.create import create  # noqa: E402
+from glaip_sdk.cli.commands.agents.delete import delete  # noqa: E402
+from glaip_sdk.cli.commands.agents.get import get  # noqa: E402
+from glaip_sdk.cli.commands.agents.list import list_agents  # noqa: E402
+from glaip_sdk.cli.commands.agents.run import _maybe_attach_transcript_toggle, run  # noqa: E402
+from glaip_sdk.cli.commands.agents.sync_langflow import sync_langflow  # noqa: E402
+from glaip_sdk.cli.commands.agents.update import update  # noqa: E402
+
+# Import core functions for test compatibility
+from glaip_sdk.cli.core.context import get_client  # noqa: E402
+
+# Import core output functions for test compatibility
+from glaip_sdk.cli.core.output import (  # noqa: E402
+    handle_resource_export,
+    output_list,
+)
+
+# Import rendering functions for test compatibility
+from glaip_sdk.cli.core.rendering import (  # noqa: E402
+    build_renderer,
+    with_client_and_spinner,  # noqa: E402
+)
+
+# Import display functions for test compatibility
+# Import display functions for test compatibility
+from glaip_sdk.cli.display import (  # noqa: E402  # noqa: E402
+    display_agent_run_suggestions,
+    handle_json_output,
+    handle_rich_output,
+)
+
+# Import IO functions for test compatibility
+from glaip_sdk.cli.io import (  # noqa: E402
+    fetch_raw_resource_details,
+)
+
+# Import rich helpers for test compatibility
+from glaip_sdk.cli.rich_helpers import (  # noqa: E402
+    markup_text,
+)
+
+# Import transcript functions for test compatibility
+from glaip_sdk.cli.transcript import (  # noqa: E402
+    maybe_launch_post_run_viewer,
+    store_transcript_for_session,
+)
+
+# Import utils for test compatibility
+from glaip_sdk.utils import (  # noqa: E402
+    is_uuid,
+)
+
+__all__ = [
+    "AGENT_NOT_FOUND_ERROR",
+    "agents_group",
+    "create",
+    "delete",
+    "get",
+    "list_agents",
+    "run",
+    "sync_langflow",
+    "update",
+    "_get_agent_for_update",
+    "_resolve_agent",
+    "_coerce_mapping_candidate",
+    "_display_agent_details",
+    "_emit_verbose_guidance",
+    "_fetch_full_agent_details",
+    "_get_agent_model_name",
+    "_get_language_model_display_name",
+    "_model_from_config",
+    "_prepare_agent_output",
+    "_resolve_resources_by_name",
+    "_maybe_attach_transcript_toggle",
+    "get_client",
+    "with_client_and_spinner",
+    "console",
+    "handle_json_output",
+    "handle_rich_output",
+    "output_list",
+    "handle_resource_export",
+    "build_renderer",
+    "display_agent_run_suggestions",
+    "markup_text",
+    "maybe_launch_post_run_viewer",
+    "store_transcript_for_session",
+    "fetch_raw_resource_details",
+    "is_uuid",
+]