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

glaip_sdk/cli/utils.py

@@ -7,29 +7,44 @@ Authors:
 
 from __future__ import annotations
 
+import importlib
 import json
 import logging
 import os
 import sys
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from contextlib import AbstractContextManager, nullcontext
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 import click
 from rich.console import Console, Group
 from rich.markdown import Markdown
 from rich.pretty import Pretty
 
+from glaip_sdk.branding import (
+    ACCENT_STYLE,
+    HINT_COMMAND_STYLE,
+    HINT_DESCRIPTION_COLOR,
+    SUCCESS_STYLE,
+    WARNING_STYLE,
+)
 from glaip_sdk.cli.rich_helpers import markup_text
+from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.rich_components import AIPPanel
 
 # Optional interactive deps (fuzzy palette)
 try:
+    from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.completion import Completion
-    from prompt_toolkit.shortcuts import prompt
+    from prompt_toolkit.selection import SelectionType
+    from prompt_toolkit.shortcuts import PromptSession, prompt
 
     _HAS_PTK = True
 except Exception:  # pragma: no cover - optional dependency
+    Buffer = None  # type: ignore[assignment]
+    SelectionType = None  # type: ignore[assignment]
+    PromptSession = None  # type: ignore[assignment]
+    prompt = None  # type: ignore[assignment]
     _HAS_PTK = False
 
 try:
@@ -114,25 +129,54 @@ def command_hint(
     return f"aip {cli_command}"
 
 
+def format_command_hint(
+    command: str | None,
+    description: str | None = None,
+) -> str | None:
+    """Return a Rich markup string that highlights a command hint.
+
+    Args:
+        command: Command text to highlight (already formatted for the active mode).
+        description: Optional short description to display alongside the command.
+
+    Returns:
+        Markup string suitable for Rich rendering, or ``None`` when ``command`` is falsy.
+    """
+    if not command:
+        return None
+
+    highlighted = f"[{HINT_COMMAND_STYLE}]{command}[/]"
+    if description:
+        highlighted += (
+            f"  [{HINT_DESCRIPTION_COLOR}]{description}[/{HINT_DESCRIPTION_COLOR}]"
+        )
+    return highlighted
+
+
 def spinner_context(
     ctx: Any | None,
     message: str,
     *,
     console_override: Console | None = None,
     spinner: str = "dots",
-    spinner_style: str = "cyan",
+    spinner_style: str = ACCENT_STYLE,
 ) -> AbstractContextManager[Any]:
     """Return a context manager that renders a spinner when appropriate."""
     active_console = console_override or console
     if not _can_use_spinner(ctx, active_console):
         return nullcontext()
 
-    return active_console.status(
+    status = active_console.status(
         message,
         spinner=spinner,
         spinner_style=spinner_style,
     )
 
+    if not hasattr(status, "__enter__") or not hasattr(status, "__exit__"):
+        return nullcontext()
+
+    return status
+
 
 def _can_use_spinner(ctx: Any | None, active_console: Console) -> bool:
     """Check if spinner output is allowed in the current environment."""
@@ -189,8 +233,8 @@ _spinner_stop = stop_spinner
 
 def get_client(ctx: Any) -> Client:  # pragma: no cover
     """Get configured client from context, env, and config file (ctx > env > file)."""
-    from glaip_sdk import Client
-
+    module = importlib.import_module("glaip_sdk")
+    client_class = cast("type[Client]", getattr(module, "Client"))
     file_config = load_config() or {}
     context_config_obj = getattr(ctx, "obj", None)
     context_config = context_config_obj or {}
@@ -223,7 +267,7 @@ def get_client(ctx: Any) -> Client:  # pragma: no cover
         actions.append("set AIP_* env vars")
         raise click.ClickException(f"Missing api_url/api_key. {' or '.join(actions)}.")
 
-    return Client(
+    return client_class(
         api_url=config.get("api_url"),
         api_key=config.get("api_key"),
         timeout=float(config.get("timeout") or 30.0),
@@ -335,6 +379,86 @@ def _build_unique_labels(
     return labels, by_label
 
 
+def _basic_prompt(
+    message: str,
+    completer: Any,
+) -> str | None:
+    """Fallback prompt handler when PromptSession is unavailable or fails."""
+    if prompt is None:  # pragma: no cover - optional dependency path
+        return None
+
+    try:
+        return prompt(
+            message=message,
+            completer=completer,
+            complete_in_thread=True,
+            complete_while_typing=True,
+        )
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug("Fallback prompt failed: %s", exc)
+        return None
+
+
+def _prompt_with_auto_select(
+    message: str,
+    completer: Any,
+    choices: Iterable[str],
+) -> str | None:
+    """Prompt with fuzzy completer that auto-selects suggested matches."""
+    if not _HAS_PTK or PromptSession is None or Buffer is None or SelectionType is None:
+        return _basic_prompt(message, completer)
+
+    try:
+        session = PromptSession(
+            message,
+            completer=completer,
+            complete_in_thread=True,
+            complete_while_typing=True,
+            reserve_space_for_menu=8,
+        )
+    except Exception as exc:  # pragma: no cover - depends on prompt_toolkit
+        logger.debug(
+            "PromptSession init failed (%s); falling back to basic prompt.", exc
+        )
+        return _basic_prompt(message, completer)
+
+    buffer = session.default_buffer
+    valid_choices = set(choices)
+
+    def _auto_select(_: Buffer) -> None:
+        text = buffer.text
+        if not text or text not in valid_choices:
+            return
+        buffer.cursor_position = 0
+        buffer.start_selection(selection_type=SelectionType.CHARACTERS)
+        buffer.cursor_position = len(text)
+
+    handler_attached = False
+    try:
+        buffer.on_text_changed += _auto_select
+        handler_attached = True
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug("Failed to attach auto-select handler: %s", exc)
+
+    try:
+        return session.prompt()
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug(
+            "PromptSession prompt failed (%s); falling back to basic prompt.", exc
+        )
+        return _basic_prompt(message, completer)
+    finally:
+        if handler_attached:
+            try:
+                buffer.on_text_changed -= _auto_select
+            except Exception:  # pragma: no cover - defensive
+                pass
+
+
 class _FuzzyCompleter:
     """Fuzzy completer for prompt_toolkit."""
 
@@ -404,17 +528,12 @@ def _fuzzy_pick(
 
     # Create fuzzy completer
     completer = _FuzzyCompleter(labels)
-
-    try:
-        answer = prompt(
-            message=f"Find {title.rstrip('s')}: ",
-            completer=completer,
-            complete_in_thread=True,
-            complete_while_typing=True,
-        )
-    except (KeyboardInterrupt, EOFError):  # pragma: no cover - user cancelled input
-        return None
-    except Exception:  # pragma: no cover - prompt_toolkit not available in headless env
+    answer = _prompt_with_auto_select(
+        f"Find {title.rstrip('s')}: ",
+        completer,
+        labels,
+    )
+    if answer is None:
         return None
 
     return _perform_fuzzy_search(answer, labels, by_label) if answer else None
@@ -557,7 +676,7 @@ def output_result(
     if panel_title:
         console.print(AIPPanel(renderable, title=panel_title))
     else:
-        console.print(markup_text(f"[cyan]{title}:[/cyan]"))
+        console.print(markup_text(f"[{ACCENT_STYLE}]{title}:[/]"))
         console.print(renderable)
 
 
@@ -665,7 +784,7 @@ def _handle_markdown_output(
 
 def _handle_empty_items(title: str) -> None:
     """Handle case when no items are found."""
-    console.print(markup_text(f"[yellow]No {title.lower()} found.[/yellow]"))
+    console.print(markup_text(f"[{WARNING_STYLE}]No {title.lower()} found.[/]"))
 
 
 def _should_use_fuzzy_picker() -> bool:
@@ -816,6 +935,18 @@ def coerce_to_row(item: Any, keys: list[str]) -> dict[str, Any]:
     return result
 
 
+def _register_renderer_with_session(ctx: Any, renderer: RichStreamRenderer) -> None:
+    """Attach renderer to an active slash session when present."""
+    try:
+        ctx_obj = getattr(ctx, "obj", None)
+        session = ctx_obj.get("_slash_session") if isinstance(ctx_obj, dict) else None
+        if session and hasattr(session, "register_active_renderer"):
+            session.register_active_renderer(renderer)
+    except Exception:
+        # Never let session bookkeeping break renderer creation
+        pass
+
+
 def build_renderer(
     _ctx: Any,
     *,
@@ -841,21 +972,17 @@ def build_renderer(
         Tuple of (renderer, capturing_console) for streaming output.
     """
     # Use capturing console if saving output
-    working_console = console
-    if save_path:
-        working_console = CapturingConsole(console, capture=True)
+    working_console = CapturingConsole(console, capture=True) if save_path else console
 
     # Configure renderer based on verbose mode and explicit overrides
-    if live is None:
-        live_enabled = not verbose  # Disable live mode in verbose (unless overridden)
-    else:
-        live_enabled = bool(live)
+    live_enabled = bool(live) if live is not None else not verbose
+    style = "debug" if verbose else "pretty"
 
     renderer_cfg = RendererConfig(
         theme=theme,
-        style="debug" if verbose else "pretty",
+        style=style,
         live=live_enabled,
-        show_delegate_tool_panels=True,
+        show_delegate_tool_panels=False,
         append_finished_snapshots=bool(snapshots)
         if snapshots is not None
         else RendererConfig.append_finished_snapshots,
@@ -871,15 +998,7 @@ def build_renderer(
     )
 
     # Link the renderer back to the slash session when running from the palette.
-    try:
-        ctx_obj = getattr(_ctx, "obj", None)
-        if isinstance(ctx_obj, dict):
-            session = ctx_obj.get("_slash_session")
-            if session and hasattr(session, "register_active_renderer"):
-                session.register_active_renderer(renderer)
-    except Exception:
-        # Never let session bookkeeping break renderer creation
-        pass
+    _register_renderer_with_session(_ctx, renderer)
 
     return renderer, working_console
 
@@ -935,15 +1054,12 @@ def _fuzzy_pick_for_resources(
 
     # Create fuzzy completer
     completer = _FuzzyCompleter(labels)
-
-    try:
-        answer = prompt(
-            message=f"Find 🤖 {resource_type.title()}: ",
-            completer=completer,
-            complete_in_thread=True,
-            complete_while_typing=True,
-        )
-    except (KeyboardInterrupt, EOFError):
+    answer = _prompt_with_auto_select(
+        f"Find {ICON_AGENT} {resource_type.title()}: ",
+        completer,
+        labels,
+    )
+    if answer is None:
         return None
 
     return _perform_fuzzy_search(answer, labels, by_label) if answer else None
@@ -967,19 +1083,19 @@ def _resolve_by_name_multiple_with_select(matches: list[Any], select: int) -> An
 def _resolve_by_name_multiple_fuzzy(
     ctx: Any, ref: str, matches: list[Any], label: str
 ) -> Any:
-    """Resolve multiple matches using fuzzy picker interface."""
-    picked = _fuzzy_pick_for_resources(matches, label.lower(), ref)
-    if picked:
-        return picked
-    # Fallback to original ambiguity handler if fuzzy picker fails
-    return handle_ambiguous_resource(ctx, label.lower(), ref, matches)
+    """Resolve multiple matches preferring the fuzzy picker interface."""
+    return handle_ambiguous_resource(
+        ctx, label.lower(), ref, matches, interface_preference="fuzzy"
+    )
 
 
 def _resolve_by_name_multiple_questionary(
     ctx: Any, ref: str, matches: list[Any], label: str
 ) -> Any:
-    """Resolve multiple matches using questionary interface."""
-    return handle_ambiguous_resource(ctx, label.lower(), ref, matches)
+    """Resolve multiple matches preferring the questionary interface."""
+    return handle_ambiguous_resource(
+        ctx, label.lower(), ref, matches, interface_preference="questionary"
+    )
 
 
 def resolve_resource(
@@ -1015,7 +1131,7 @@ def resolve_resource(
     _spinner_update(spinner, f"[bold blue]Fetching {label} by ID…[/bold blue]")
     result = _resolve_by_id(ref, get_by_id)
     if result is not None:
-        _spinner_update(spinner, f"[bold green]{label} found[/bold green]")
+        _spinner_update(spinner, f"[{SUCCESS_STYLE}]{label} found[/]")
         return result
 
     # If get_by_id returned None, the resource doesn't exist
@@ -1033,7 +1149,7 @@ def resolve_resource(
         raise click.ClickException(f"{label} '{ref}' not found")
 
     if len(matches) == 1:
-        _spinner_update(spinner, f"[bold green]{label} found[/bold green]")
+        _spinner_update(spinner, f"[{SUCCESS_STYLE}]{label} found[/]")
         return matches[0]
 
     # Multiple matches found, handle ambiguity
@@ -1043,7 +1159,10 @@ def resolve_resource(
 
     # Choose interface based on preference
     _spinner_stop(spinner)
-    if interface_preference == "fuzzy":
+    preference = (interface_preference or "fuzzy").lower()
+    if preference not in {"fuzzy", "questionary"}:
+        preference = "fuzzy"
+    if preference == "fuzzy":
         return _resolve_by_name_multiple_fuzzy(ctx, ref, matches, label)
     else:
         return _resolve_by_name_multiple_questionary(ctx, ref, matches, label)
@@ -1093,7 +1212,7 @@ def _handle_fallback_numeric_ambiguity(
 
     console.print(
         markup_text(
-            f"[yellow]Multiple {safe_resource_type}s found matching '{safe_ref}':[/yellow]"
+            f"[{WARNING_STYLE}]Multiple {safe_resource_type}s found matching '{safe_ref}':[/]"
         )
     )
     table = AIPTable(
@@ -1101,7 +1220,7 @@ def _handle_fallback_numeric_ambiguity(
     )
     table.add_column("#", style="dim", width=3)
     table.add_column("ID", style="dim", width=36)
-    table.add_column("Name", style="cyan")
+    table.add_column("Name", style=ACCENT_STYLE)
     for i, m in enumerate(matches, 1):
         table.add_row(str(i), str(getattr(m, "id", "")), str(getattr(m, "name", "")))
     console.print(table)
@@ -1127,22 +1246,85 @@ def _should_fallback_to_numeric_prompt(exception: Exception) -> bool:
     return True
 
 
+def _normalize_interface_preference(preference: str) -> str:
+    """Normalize and validate interface preference."""
+    normalized = (preference or "questionary").lower()
+    return normalized if normalized in {"fuzzy", "questionary"} else "questionary"
+
+
+def _get_interface_order(preference: str) -> tuple[str, str]:
+    """Get the ordered interface preferences."""
+    interface_orders = {
+        "fuzzy": ("fuzzy", "questionary"),
+        "questionary": ("questionary", "fuzzy"),
+    }
+    return interface_orders.get(preference, ("questionary", "fuzzy"))
+
+
+def _try_fuzzy_selection(
+    resource_type: str,
+    ref: str,
+    matches: list[Any],
+) -> Any | None:
+    """Try fuzzy interface selection."""
+    picked = _fuzzy_pick_for_resources(matches, resource_type, ref)
+    return picked if picked else None
+
+
+def _try_questionary_selection(
+    resource_type: str,
+    ref: str,
+    matches: list[Any],
+) -> Any | None:
+    """Try questionary interface selection."""
+    try:
+        return _handle_questionary_ambiguity(resource_type, ref, matches)
+    except Exception as exc:
+        if not _should_fallback_to_numeric_prompt(exc):
+            raise
+        return None
+
+
+def _try_interface_selection(
+    interface_order: tuple[str, str],
+    resource_type: str,
+    ref: str,
+    matches: list[Any],
+) -> Any | None:
+    """Try interface selection in order, return result or None if all failed."""
+    interface_handlers = {
+        "fuzzy": _try_fuzzy_selection,
+        "questionary": _try_questionary_selection,
+    }
+
+    for interface in interface_order:
+        handler = interface_handlers.get(interface)
+        if handler:
+            result = handler(resource_type, ref, matches)
+            if result:
+                return result
+
+    return None
+
+
 def handle_ambiguous_resource(
-    ctx: Any, resource_type: str, ref: str, matches: list[Any]
+    ctx: Any,
+    resource_type: str,
+    ref: str,
+    matches: list[Any],
+    *,
+    interface_preference: str = "questionary",
 ) -> Any:
     """Handle multiple resource matches gracefully."""
     if _get_view(ctx) == "json":
         return _handle_json_view_ambiguity(matches)
 
-    try:
-        return _handle_questionary_ambiguity(resource_type, ref, matches)
-    except Exception as e:
-        if _should_fallback_to_numeric_prompt(e):
-            try:
-                return _handle_fallback_numeric_ambiguity(resource_type, ref, matches)
-            except Exception:
-                # If fallback also fails, re-raise the original exception
-                raise e
-        else:
-            # Re-raise cancellation exceptions
-            raise
+    preference = _normalize_interface_preference(interface_preference)
+    interface_order = _get_interface_order(preference)
+
+    result = _try_interface_selection(interface_order, resource_type, ref, matches)
+
+    if result is not None:
+        return result
+
+    return _handle_fallback_numeric_ambiguity(resource_type, ref, matches)

glaip_sdk/client/agents.py

@@ -928,6 +928,8 @@ class AgentClient(BaseClient):
         started_monotonic: float | None = None
         finished_monotonic: float | None = None
 
+        timeout_seconds = compute_timeout_seconds(kwargs)
+
         try:
             response = self.http_client.stream(
                 "POST",
@@ -936,12 +938,12 @@ class AgentClient(BaseClient):
                 data=data_payload,
                 files=files_payload,
                 headers=headers,
+                timeout=timeout_seconds,
             )
 
             with response as stream_response:
                 stream_response.raise_for_status()
 
-                timeout_seconds = compute_timeout_seconds(kwargs)
                 agent_name = kwargs.get("agent_name")
 
                 (

glaip_sdk/client/run_rendering.py

@@ -106,7 +106,7 @@ class AgentRunRenderingManager:
             theme="dark",
             style="debug",
             live=False,
-            show_delegate_tool_panels=True,
+            show_delegate_tool_panels=False,
             append_finished_snapshots=False,
         )
         return RichStreamRenderer(
@@ -118,7 +118,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)
 
     # --------------------------------------------------------------------- #

glaip_sdk/icons.py

@@ -0,0 +1,19 @@
+"""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
+
+__all__ = [
+    "ICON_AGENT",
+    "ICON_AGENT_STEP",
+    "ICON_TOOL",
+    "ICON_TOOL_STEP",
+    "ICON_DELEGATE",
+]

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)