glaip-sdk 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

glaip_sdk/branding.py

@@ -31,8 +31,8 @@ except Exception:  # pragma: no cover
 
 
 # ---- minimal, readable styles (light blue + white theme) -----------------
-PRIMARY = "bright_blue"  # Light blue for main elements
-BORDER = "bright_blue"  # Light blue borders
+PRIMARY = "#15a2d8"  # GDP Labs brand blue
+BORDER = PRIMARY  # Keep borders aligned with brand tone
 TITLE_STYLE = f"bold {PRIMARY}"
 LABEL = "bold"
 
@@ -95,7 +95,7 @@ GDP Labs AI Agents Package
     # ---- public API -----------------------------------------------------------
     def get_welcome_banner(self) -> str:
         """Get AIP banner with version info."""
-        banner = self.AIP_LOGO
+        banner = f"[{PRIMARY}]{self.AIP_LOGO}[/{PRIMARY}]"
         line = f"Version: {self.version}"
         banner = f"{banner}\n{line}"
         return banner

glaip_sdk/cli/commands/agents.py

@@ -6,6 +6,7 @@ Authors:
 
 import json
 import os
+from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
@@ -53,6 +54,7 @@ from glaip_sdk.cli.utils import (
     output_flags,
     output_list,
     output_result,
+    spinner_context,
 )
 from glaip_sdk.cli.validators import (
     validate_agent_instruction_cli as validate_agent_instruction,
@@ -76,6 +78,91 @@ console = Console()
 AGENT_NOT_FOUND_ERROR = "Agent not found"
 
 
+def _safe_agent_attribute(agent: Any, name: str) -> Any:
+    """Return attribute value for ``name`` while filtering Mock sentinels."""
+
+    try:
+        value = getattr(agent, name)
+    except Exception:
+        return None
+
+    if hasattr(value, "_mock_name"):
+        return None
+    return value
+
+
+def _coerce_mapping_candidate(candidate: Any) -> dict[str, Any] | None:
+    """Convert a mapping-like candidate to a plain dict when possible."""
+
+    if candidate is None:
+        return None
+    if isinstance(candidate, Mapping):
+        return dict(candidate)
+    return None
+
+
+def _call_agent_method(agent: Any, method_name: str) -> dict[str, Any] | None:
+    """Attempt to call the named method and coerce its output to a dict."""
+
+    method = getattr(agent, method_name, None)
+    if not callable(method):
+        return None
+    try:
+        candidate = method()
+    except Exception:
+        return None
+    return _coerce_mapping_candidate(candidate)
+
+
+def _coerce_agent_via_methods(agent: Any) -> dict[str, Any] | None:
+    """Try standard serialisation helpers to produce a mapping."""
+
+    for attr in ("model_dump", "dict", "to_dict"):
+        mapping = _call_agent_method(agent, attr)
+        if mapping is not None:
+            return mapping
+    return None
+
+
+def _build_fallback_agent_mapping(agent: Any) -> dict[str, Any]:
+    """Construct a minimal mapping from well-known agent attributes."""
+
+    fallback_fields = (
+        "id",
+        "name",
+        "instruction",
+        "description",
+        "model",
+        "agent_config",
+        "tools",
+        "agents",
+        "mcps",
+        "timeout",
+    )
+
+    fallback: dict[str, Any] = {}
+    for field in fallback_fields:
+        value = _safe_agent_attribute(agent, field)
+        if value is not None:
+            fallback[field] = value
+
+    return fallback or {"name": str(agent)}
+
+
+def _prepare_agent_output(agent: Any) -> dict[str, Any]:
+    """Build a JSON-serialisable mapping for CLI output."""
+
+    method_mapping = _coerce_agent_via_methods(agent)
+    if method_mapping is not None:
+        return method_mapping
+
+    intrinsic = _coerce_mapping_candidate(agent)
+    if intrinsic is not None:
+        return intrinsic
+
+    return _build_fallback_agent_mapping(agent)
+
+
 def _fetch_full_agent_details(client: Any, agent: Any) -> Any | None:
     """Fetch full agent details by ID to ensure all fields are populated."""
     try:
@@ -199,7 +286,12 @@ def _display_agent_details(ctx: Any, client: Any, agent: Any) -> None:
         return
 
     # Try to fetch and format raw agent data first
-    formatted_data = _fetch_and_format_raw_agent_data(client, agent)
+    with spinner_context(
+        ctx,
+        "[bold blue]Loading agent details…[/bold blue]",
+        console_override=console,
+    ):
+        formatted_data = _fetch_and_format_raw_agent_data(client, agent)
 
     if formatted_data:
         # Use raw API data - this preserves ALL fields including account_id
@@ -216,7 +308,12 @@ def _display_agent_details(ctx: Any, client: Any, agent: Any) -> None:
             ctx, Text("[yellow]Falling back to Pydantic model data[/yellow]")
         )
 
-        result_data = _format_fallback_agent_data(client, agent)
+        with spinner_context(
+            ctx,
+            "[bold blue]Preparing fallback agent details…[/bold blue]",
+            console_override=console,
+        ):
+            result_data = _format_fallback_agent_data(client, agent)
 
         # Display using output_result
         output_result(
@@ -289,13 +386,18 @@ def list_agents(
     """List agents with optional filtering."""
     try:
         client = get_client(ctx)
-        agents = client.agents.list_agents(
-            agent_type=agent_type,
-            framework=framework,
-            name=name,
-            version=version,
-            sync_langflow_agents=sync_langflow,
-        )
+        with spinner_context(
+            ctx,
+            "[bold blue]Fetching agents…[/bold blue]",
+            console_override=console,
+        ):
+            agents = client.agents.list_agents(
+                agent_type=agent_type,
+                framework=framework,
+                name=name,
+                version=version,
+                sync_langflow_agents=sync_langflow,
+            )
 
         # Define table columns: (data_key, header, style, width)
         columns = [
@@ -364,7 +466,12 @@ def get(ctx: Any, agent_ref: str, select: int | None, export: str | None) -> Non
 
             # Always export comprehensive data - re-fetch agent with full details
             try:
-                agent = client.agents.get_agent_by_id(agent.id)
+                with spinner_context(
+                    ctx,
+                    "[bold blue]Fetching complete agent data…[/bold blue]",
+                    console_override=console,
+                ):
+                    agent = client.agents.get_agent_by_id(agent.id)
             except Exception as e:
                 handle_rich_output(
                     ctx,
@@ -776,7 +883,7 @@ def _get_language_model_display_name(agent: Any, model: str | None) -> str:
 
 def _handle_successful_creation(ctx: Any, agent: Any, model: str | None) -> None:
     """Handle successful agent creation output."""
-    handle_json_output(ctx, agent.model_dump())
+    handle_json_output(ctx, _prepare_agent_output(agent))
 
     lm_display = _get_language_model_display_name(agent, model)
 
@@ -1080,7 +1187,7 @@ def update(
 
         updated_agent = client.agents.update_agent(agent.id, **update_data)
 
-        handle_json_output(ctx, updated_agent.model_dump())
+        handle_json_output(ctx, _prepare_agent_output(updated_agent))
         handle_rich_output(ctx, display_update_success("Agent", updated_agent.name))
         handle_rich_output(ctx, display_agent_run_suggestions(updated_agent))
 

glaip_sdk/cli/display.py

@@ -247,9 +247,10 @@ def display_agent_run_suggestions(agent: Any) -> Panel:
 
     return AIPPanel(
         f"[bold blue]💡 Next Steps:[/bold blue]\n\n"
-        f"🚀 Run this agent:\n"
-        f'   [green]aip agents run {agent.id} "Your message here"[/green]\n\n'
-        f"📋 Or use the agent name:\n"
+        f"🚀 Start chatting with [bold]{agent.name}[/bold] right here:\n"
+        f"   Type your message below and press Enter to run it immediately.\n\n"
+        f"📋 Prefer the CLI instead?\n"
+        f'   [green]aip agents run {agent.id} "Your message here"[/green]\n'
         f'   [green]aip agents run "{agent.name}" "Your message here"[/green]\n\n'
         f"🔧 Available options:\n"
         f"   [dim]--chat-history[/dim]  Include previous conversation\n"

glaip_sdk/cli/main.py

@@ -24,11 +24,21 @@ from glaip_sdk.cli.commands.configure import (
 from glaip_sdk.cli.commands.mcps import mcps_group
 from glaip_sdk.cli.commands.models import models_group
 from glaip_sdk.cli.commands.tools import tools_group
-from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
+from glaip_sdk.cli.utils import spinner_context
+from glaip_sdk.config.constants import (
+    DEFAULT_AGENT_RUN_TIMEOUT,
+)
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 
+# Import SlashSession for potential mocking in tests
+try:
+    from glaip_sdk.cli.slash import SlashSession
+except ImportError:  # pragma: no cover - optional slash dependencies
+    # Slash dependencies might not be available in all environments
+    SlashSession = None
+
 
-@click.group()
+@click.group(invoke_without_command=True)
 @click.version_option(version=_SDK_VERSION, prog_name="aip")
 @click.option("--api-url", envvar="AIP_API_URL", help="AIP API URL")
 @click.option("--api-key", envvar="AIP_API_KEY", help="AIP API Key")
@@ -72,6 +82,15 @@ def main(
 
     ctx.obj["tty"] = not no_tty
 
+    if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
+        if _should_launch_slash(ctx) and SlashSession is not None:
+            session = SlashSession(ctx)
+            session.run()
+            ctx.exit()
+        else:
+            click.echo(ctx.get_help())
+            ctx.exit()
+
 
 # Add command groups
 main.add_command(agents_group)
@@ -87,6 +106,19 @@ main.add_command(configure_command)
 # Tip: `--version` is provided by click.version_option above.
 
 
+def _should_launch_slash(ctx: click.Context) -> bool:
+    """Determine whether to open the command palette automatically."""
+
+    ctx_obj = ctx.obj or {}
+    if not bool(ctx_obj.get("tty", True)):
+        return False
+
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return False
+
+    return True
+
+
 @main.command()
 @click.pass_context
 def status(ctx: Any) -> None:
@@ -152,9 +184,23 @@ def status(ctx: Any) -> None:
 
         # Test connection by listing resources
         try:
-            agents = client.list_agents()
-            tools = client.list_tools()
-            mcps = client.list_mcps()
+            with spinner_context(
+                ctx,
+                "[bold blue]Checking GL AIP status…[/bold blue]",
+                console_override=console,
+                spinner_style="cyan",
+            ) as status_indicator:
+                if status_indicator is not None:
+                    status_indicator.update("[bold blue]Fetching agents…[/bold blue]")
+                agents = client.list_agents()
+
+                if status_indicator is not None:
+                    status_indicator.update("[bold blue]Fetching tools…[/bold blue]")
+                tools = client.list_tools()
+
+                if status_indicator is not None:
+                    status_indicator.update("[bold blue]Fetching MCPs…[/bold blue]")
+                mcps = client.list_mcps()
 
             # Create status table
             table = AIPTable(title="🔗 GL AIP Status")

glaip_sdk/cli/resolution.py

@@ -12,7 +12,7 @@ from typing import Any
 
 import click
 
-from glaip_sdk.cli.utils import resolve_resource
+from glaip_sdk.cli.utils import resolve_resource, spinner_context
 
 
 def resolve_resource_reference(
@@ -25,6 +25,7 @@ def resolve_resource_reference(
     label: str,
     select: int | None = None,
     interface_preference: str | None = None,
+    spinner_message: str | None = None,
 ) -> Any | None:
     """Resolve resource reference (ID or name) with ambiguity handling.
 
@@ -47,14 +48,21 @@ def resolve_resource_reference(
         click.ClickException: If resolution fails
     """
     try:
-        return resolve_resource(
-            ctx,
-            reference,
-            get_by_id=get_by_id_func,
-            find_by_name=find_by_name_func,
-            label=label,
-            select=select,
-            interface_preference=interface_preference,
+        message = (
+            spinner_message
+            if spinner_message is not None
+            else f"[bold blue]Fetching {label}…[/bold blue]"
         )
+        with spinner_context(ctx, message, spinner_style="cyan") as status_indicator:
+            return resolve_resource(
+                ctx,
+                reference,
+                get_by_id=get_by_id_func,
+                find_by_name=find_by_name_func,
+                label=label,
+                select=select,
+                interface_preference=interface_preference,
+                status_indicator=status_indicator,
+            )
     except Exception as e:
         raise click.ClickException(f"Failed to resolve {resource_type.lower()}: {e}")

glaip_sdk/cli/slash/__init__.py

@@ -0,0 +1,25 @@
+"""Slash command palette entrypoints.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from glaip_sdk.cli.commands.agents import get as agents_get_command
+from glaip_sdk.cli.commands.agents import run as agents_run_command
+from glaip_sdk.cli.commands.configure import configure_command, load_config
+from glaip_sdk.cli.utils import get_client
+
+from .agent_session import AgentRunSession
+from .prompt import _HAS_PROMPT_TOOLKIT
+from .session import SlashSession
+
+__all__ = [
+    "AgentRunSession",
+    "SlashSession",
+    "_HAS_PROMPT_TOOLKIT",
+    "agents_get_command",
+    "agents_run_command",
+    "configure_command",
+    "get_client",
+    "load_config",
+]

glaip_sdk/cli/slash/agent_session.py

@@ -0,0 +1,146 @@
+"""Agent-specific interaction loop for the command palette.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from glaip_sdk.cli.commands.agents import get as agents_get_command
+from glaip_sdk.cli.commands.agents import run as agents_run_command
+
+if TYPE_CHECKING:  # pragma: no cover - type checking only
+    from .session import SlashSession
+
+
+class AgentRunSession:
+    """Per-agent execution context for the command palette."""
+
+    def __init__(self, session: SlashSession, agent: Any) -> None:
+        self.session = session
+        self.agent = agent
+        self.console = session.console
+        self._agent_id = str(getattr(agent, "id", ""))
+        self._agent_name = getattr(agent, "name", "") or self._agent_id
+        self._prompt_placeholder: str = (
+            "Chat with this agent here; use / for shortcuts."
+        )
+        self._contextual_completion_help: dict[str, str] = {
+            "details": "Show this agent's full configuration.",
+            "help": "Display this context-aware menu.",
+            "exit": "Return to the command palette.",
+            "q": "Return to the command palette.",
+        }
+
+    def run(self) -> None:
+        self.session.set_contextual_commands(
+            self._contextual_completion_help, include_global=False
+        )
+        try:
+            self._display_agent_info()
+            self._run_agent_loop()
+        finally:
+            self.session.set_contextual_commands(None)
+
+    def _display_agent_info(self) -> None:
+        """Display agent information and summary."""
+        self.session._render_header(self.agent, focus_agent=True)
+
+    def _run_agent_loop(self) -> None:
+        """Run the main agent interaction loop."""
+        while True:
+            raw = self._get_user_input()
+            if raw is None:
+                return
+
+            raw = raw.strip()
+            if not raw:
+                continue
+
+            if raw.startswith("/"):
+                if not self._handle_slash_command(raw, self._agent_id):
+                    return
+                continue
+
+            self._run_agent(self._agent_id, raw)
+
+    def _get_user_input(self) -> str | None:
+        """Get user input with proper error handling."""
+        try:
+            raw = self.session._prompt(
+                f"{self._agent_name} ({self._agent_id})\n› ",
+                placeholder=self._prompt_placeholder,
+            )
+            if self._prompt_placeholder:
+                # Show the guidance once, then fall back to a clean prompt.
+                self._prompt_placeholder = ""
+            return raw
+        except EOFError:
+            self.console.print("\nExiting agent context.")
+            return None
+        except KeyboardInterrupt:
+            self.console.print("")
+            return ""
+
+    def _handle_slash_command(self, raw: str, agent_id: str) -> bool:
+        """Handle slash commands in agent context. Returns False if should exit."""
+        # Handle simple commands first
+        if raw == "/":
+            return self._handle_help_command()
+
+        if raw in {"/exit", "/back", "/q"}:
+            return self._handle_exit_command()
+
+        if raw in {"/details", "/detail"}:
+            return self._handle_details_command(agent_id)
+
+        if raw in {"/help", "/?"}:
+            return self._handle_help_command()
+
+        # Handle other commands through the main session
+        return self._handle_other_command(raw)
+
+    def _handle_help_command(self) -> bool:
+        """Handle help command."""
+        self.session._cmd_help([], True)
+        return True
+
+    def _handle_exit_command(self) -> bool:
+        """Handle exit command."""
+        self.console.print("[dim]Returning to the main prompt.[/dim]")
+        return False
+
+    def _handle_details_command(self, agent_id: str) -> bool:
+        """Handle details command."""
+        self._show_details(agent_id)
+        return True
+
+    def _handle_other_command(self, raw: str) -> bool:
+        """Handle other commands through the main session."""
+        self.session.handle_command(raw, invoked_from_agent=True)
+        return not self.session._should_exit
+
+    def _show_details(self, agent_id: str) -> None:
+        try:
+            self.session.ctx.invoke(agents_get_command, agent_ref=agent_id)
+            self.console.print(
+                "[dim]Tip: Continue the conversation in this prompt, or use /help for shortcuts."
+            )
+        except click.ClickException as exc:
+            self.console.print(f"[red]{exc}[/red]")
+
+    def _run_agent(self, agent_id: str, message: str) -> None:
+        if not message:
+            return
+
+        try:
+            self.session.ctx.invoke(
+                agents_run_command, agent_ref=agent_id, input_text=message
+            )
+            self.session.last_run_input = message
+        except click.ClickException as exc:
+            self.console.print(f"[red]{exc}[/red]")