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

glaip_sdk/cli/update_notifier.py

@@ -8,12 +8,19 @@ from __future__ import annotations
 
 import os
 from collections.abc import Callable
+from typing import Any, Literal
 
 import httpx
 from packaging.version import InvalidVersion, Version
+from rich import box
 from rich.console import Console
 
-from glaip_sdk.cli.utils import command_hint
+from glaip_sdk.branding import (
+    ACCENT_STYLE,
+    SUCCESS_STYLE,
+    WARNING_STYLE,
+)
+from glaip_sdk.cli.utils import command_hint, format_command_hint
 from glaip_sdk.rich_components import AIPPanel
 
 FetchLatestVersion = Callable[[], str | None]
@@ -63,16 +70,20 @@ def _build_update_panel(
     command_text: str,
 ) -> AIPPanel:
     """Create a Rich panel that prompts the user to update."""
+    command_markup = format_command_hint(command_text) or command_text
     message = (
-        f"[bold yellow]✨ Update available![/bold yellow] "
+        f"[{WARNING_STYLE}]✨ Update available![/] "
         f"{current_version} → {latest_version}\n\n"
         "See the latest release notes:\n"
         f"https://pypi.org/project/glaip-sdk/{latest_version}/\n\n"
-        f"[cyan]Run[/cyan] [bold]{command_text}[/bold] to install."
+        f"[{ACCENT_STYLE}]Run[/] {command_markup} to install."
     )
     return AIPPanel(
         message,
-        title="[bold green]AIP SDK Update[/bold green]",
+        title=f"[{SUCCESS_STYLE}]AIP SDK Update[/]",
+        box=box.ROUNDED,
+        padding=(0, 3),
+        expand=False,
     )
 
 
@@ -82,6 +93,9 @@ def maybe_notify_update(
     package_name: str = "glaip-sdk",
     console: Console | None = None,
     fetch_latest_version: FetchLatestVersion | None = None,
+    ctx: Any | None = None,
+    slash_command: str | None = None,
+    style: Literal["panel", "inline"] = "panel",
 ) -> None:
     """Check PyPI for a newer version and display a prompt if one exists.
 
@@ -101,11 +115,21 @@ def maybe_notify_update(
     if current is None or latest is None or latest <= current:
         return
 
-    command_text = command_hint("update")
+    command_text = command_hint("update", slash_command=slash_command, ctx=ctx)
     if command_text is None:
         return
 
     active_console = console or Console()
+    if style == "inline":
+        command_markup = format_command_hint(command_text) or command_text
+        message = (
+            f"[{WARNING_STYLE}]✨ Update[/] "
+            f"{current_version} → {latest_version} "
+            f"- {command_markup}"
+        )
+        active_console.print(message)
+        return
+
     panel = _build_update_panel(current_version, latest_version, command_text)
     active_console.print(panel)
 

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,16 @@ 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,
         append_finished_snapshots=bool(snapshots)
         if snapshots is not None
         else RendererConfig.append_finished_snapshots,
@@ -871,15 +997,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 +1053,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 +1082,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 +1130,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 +1148,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 +1158,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 +1211,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 +1219,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 +1245,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")
 
                 (