glaip-sdk 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

glaip_sdk/cli/update_notifier.py

@@ -26,7 +26,8 @@ from glaip_sdk.branding import (
 )
 from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.constants import UPDATE_CHECK_ENABLED
-from glaip_sdk.cli.utils import command_hint, format_command_hint
+from glaip_sdk.cli.hints import format_command_hint
+from glaip_sdk.cli.utils import command_hint
 from glaip_sdk.rich_components import AIPPanel
 
 FetchLatestVersion = Callable[[], str | None]

glaip_sdk/cli/utils.py

@@ -7,12 +7,12 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import json
 import logging
 import os
 import sys
-import asyncio
 from collections.abc import Callable, Iterable
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from pathlib import Path
@@ -27,19 +27,21 @@ from rich.syntax import Syntax
 from glaip_sdk import _version as _version_module
 from glaip_sdk.branding import (
     ACCENT_STYLE,
-    HINT_COMMAND_STYLE,
-    HINT_DESCRIPTION_COLOR,
     SUCCESS_STYLE,
     WARNING_STYLE,
 )
+from glaip_sdk.cli import display as cli_display
 from glaip_sdk.cli import masking, pager
-from glaip_sdk.cli.constants import LITERAL_STRING_THRESHOLD, TABLE_SORT_ENABLED
 from glaip_sdk.cli.config import load_config
+from glaip_sdk.cli.constants import LITERAL_STRING_THRESHOLD, TABLE_SORT_ENABLED
 from glaip_sdk.cli.context import (
     _get_view,
-    detect_export_format as _detect_export_format,
     get_ctx_value,
 )
+from glaip_sdk.cli.context import (
+    detect_export_format as _detect_export_format,
+)
+from glaip_sdk.cli.hints import command_hint
 from glaip_sdk.cli.io import export_resource_to_file_with_validation
 from glaip_sdk.cli.rich_helpers import markup_text, print_markup
 from glaip_sdk.icons import ICON_AGENT
@@ -47,10 +49,35 @@ from glaip_sdk.rich_components import AIPPanel, AIPTable
 from glaip_sdk.utils import format_datetime, is_uuid
 from glaip_sdk.utils.rendering.renderer import (
     CapturingConsole,
-    RendererConfig,
+    RendererFactoryOptions,
     RichStreamRenderer,
+    make_default_renderer,
+    make_verbose_renderer,
 )
 
+questionary = None  # type: ignore[assignment]
+
+
+def _load_questionary_module() -> tuple[Any | None, Any | None]:
+    """Return the questionary module and Choice class if available."""
+    module = questionary
+    if module is not None:
+        return module, getattr(module, "Choice", None)
+
+    try:  # pragma: no cover - optional dependency
+        module = __import__("questionary")
+    except ImportError:
+        return None, None
+
+    return module, getattr(module, "Choice", None)
+
+
+def _make_questionary_choice(choice_cls: Any | None, **kwargs: Any) -> Any:
+    """Create a questionary Choice instance or lightweight fallback."""
+    if choice_cls is None:
+        return kwargs
+    return choice_cls(**kwargs)
+
 
 @contextmanager
 def bind_slash_session_context(ctx: Any, session: Any) -> Any:
@@ -122,31 +149,28 @@ def prompt_export_choice_questionary(
         Tuple of (choice, path) or None if cancelled/unavailable.
         Choice can be "default", "custom", or "cancel".
     """
-    # Import here for optional dependency (questionary may not be installed)
-    try:  # pragma: no cover - optional dependency
-        import questionary
-        from questionary import Choice
-    except Exception:  # pragma: no cover - optional dependency
-        return None
-
-    if questionary is None or Choice is None:
+    questionary_module, choice_cls = _load_questionary_module()
+    if questionary_module is None or choice_cls is None:
         return None
 
     try:
-        question = questionary.select(
+        question = questionary_module.select(
             "Export transcript",
             choices=[
-                Choice(
+                _make_questionary_choice(
+                    choice_cls,
                     title=f"Save to default ({default_display})",
                     value=("default", default_path),
                     shortcut_key="1",
                 ),
-                Choice(
+                _make_questionary_choice(
+                    choice_cls,
                     title="Choose a different path",
                     value=("custom", None),
                     shortcut_key="2",
                 ),
-                Choice(
+                _make_questionary_choice(
+                    choice_cls,
                     title="Cancel",
                     value=("cancel", None),
                     shortcut_key="3",
@@ -194,9 +218,7 @@ def _run_questionary_in_thread(question: Any, *, patch_stdout: bool = False) ->
     run_callable = getattr(application, "run", None) if application is not None else None
     if callable(run_callable):
         try:
-            if patch_stdout:
-                from prompt_toolkit.patch_stdout import patch_stdout as pt_patch_stdout
-
+            if patch_stdout and pt_patch_stdout is not None:
                 with pt_patch_stdout():
                     return run_callable(in_thread=True)
             return run_callable(in_thread=True)
@@ -226,6 +248,7 @@ _LiteralYamlDumper.add_representer(str, _literal_str_representer)
 try:
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.completion import Completion
+    from prompt_toolkit.patch_stdout import patch_stdout as pt_patch_stdout
     from prompt_toolkit.selection import SelectionType
     from prompt_toolkit.shortcuts import PromptSession, prompt
 
@@ -235,13 +258,9 @@ except Exception:  # pragma: no cover - optional dependency
     SelectionType = None  # type: ignore[assignment]
     PromptSession = None  # type: ignore[assignment]
     prompt = None  # type: ignore[assignment]
+    pt_patch_stdout = None  # type: ignore[assignment]
     _HAS_PTK = False
 
-try:
-    import questionary
-except Exception:  # pragma: no cover - optional dependency
-    questionary = None
-
 if TYPE_CHECKING:  # pragma: no cover - import-only during type checking
     from glaip_sdk import Client
 
@@ -401,9 +420,7 @@ def handle_resource_export(
         ):
             export_resource_to_file_with_validation(full_resource, export_path, detected_format)
     except Exception:
-        from glaip_sdk.cli.display import handle_rich_output  # noqa: E402 - avoid circular import
-
-        handle_rich_output(
+        cli_display.handle_rich_output(
             ctx,
             markup_text(f"[{WARNING_STYLE}]⚠️  Failed to fetch full details, using available data[/]"),
         )
@@ -416,73 +433,6 @@ def handle_resource_export(
     )
 
 
-def in_slash_mode(ctx: click.Context | None = None) -> bool:
-    """Return True when running inside the slash command palette."""
-    if ctx is None:
-        try:
-            ctx = click.get_current_context(silent=True)
-        except RuntimeError:
-            ctx = None
-
-    if ctx is None:
-        return False
-
-    obj = getattr(ctx, "obj", None)
-    if isinstance(obj, dict):
-        return bool(obj.get("_slash_session"))
-
-    return bool(getattr(obj, "_slash_session", False))
-
-
-def command_hint(
-    cli_command: str | None,
-    slash_command: str | None = None,
-    *,
-    ctx: click.Context | None = None,
-) -> str | None:
-    """Return the appropriate command string for the current mode.
-
-    Args:
-        cli_command: Command string without the ``aip`` prefix (e.g., ``"status"``).
-        slash_command: Slash command counterpart (e.g., ``"status"`` or ``"/status"``).
-        ctx: Optional Click context override.
-
-    Returns:
-        The formatted command string for the active mode, or ``None`` when no
-        equivalent command exists in that mode.
-    """
-    if in_slash_mode(ctx):
-        if not slash_command:
-            return None
-        return slash_command if slash_command.startswith("/") else f"/{slash_command}"
-
-    if not cli_command:
-        return None
-    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 sdk_version() -> str:
     """Return the current SDK version, warning if metadata is unavailable."""
     version = getattr(_version_module, "__version__", None)
@@ -598,45 +548,48 @@ _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)."""
+    """Get configured client from context and account store (ctx > account)."""
+    # Import here to avoid circular import
+    from glaip_sdk.cli.auth import resolve_credentials  # noqa: PLC0415
+
     module = importlib.import_module("glaip_sdk")
     client_class = cast("type[Client]", module.Client)
-    file_config = load_config() or {}
     context_config_obj = getattr(ctx, "obj", None)
     context_config = context_config_obj or {}
 
-    raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
-    try:
-        timeout_value = float(raw_timeout)
-    except ValueError:
-        timeout_value = None
-
-    env_config = {
-        "api_url": os.getenv("AIP_API_URL"),
-        "api_key": os.getenv("AIP_API_KEY"),
-        "timeout": timeout_value if timeout_value else None,
-    }
-    env_config = {k: v for k, v in env_config.items() if v not in (None, "", 0)}
-
-    # Merge config sources: context > env > file
-    config = {
-        **file_config,
-        **env_config,
-        **{k: v for k, v in context_config.items() if v is not None},
-    }
+    account_name = context_config.get("account_name")
+    api_url, api_key, _ = resolve_credentials(
+        account_name=account_name,
+        api_url=context_config.get("api_url"),
+        api_key=context_config.get("api_key"),
+    )
 
-    if not config.get("api_url") or not config.get("api_key"):
-        configure_hint = command_hint("configure", slash_command="login", ctx=ctx)
-        actions = []
+    if not api_url or not api_key:
+        configure_hint = command_hint("accounts add", slash_command="login", ctx=ctx)
+        actions: list[str] = []
         if configure_hint:
-            actions.append(f"Run `{configure_hint}`")
-        actions.append("set AIP_* env vars")
+            actions.append(f"Run `{configure_hint}` to add an account profile")
+        else:
+            actions.append("add an account with 'aip accounts add'")
         raise click.ClickException(f"Missing api_url/api_key. {' or '.join(actions)}.")
 
+    # Get timeout from context or config
+    timeout = context_config.get("timeout")
+    if timeout is None:
+        raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
+        try:
+            timeout = float(raw_timeout) if raw_timeout != "0" else None
+        except ValueError:
+            timeout = None
+    if timeout is None:
+        # Fallback to legacy config
+        file_config = load_config() or {}
+        timeout = file_config.get("timeout")
+
     return client_class(
-        api_url=config.get("api_url"),
-        api_key=config.get("api_key"),
-        timeout=float(config.get("timeout") or 30.0),
+        api_url=api_url,
+        api_key=api_key,
+        timeout=float(timeout or 30.0),
     )
 
 
@@ -1358,19 +1311,20 @@ def build_renderer(
 
     # Configure renderer based on verbose mode and explicit overrides
     live_enabled = bool(live) if live is not None else not verbose
-    renderer_cfg = RendererConfig(
-        live=live_enabled,
-        append_finished_snapshots=bool(snapshots)
-        if snapshots is not None
-        else RendererConfig.append_finished_snapshots,
+    cfg_overrides = {
+        "live": live_enabled,
+        "append_finished_snapshots": bool(snapshots) if snapshots is not None else False,
+    }
+    renderer_console = (
+        working_console.original_console if isinstance(working_console, CapturingConsole) else working_console
     )
-
-    # Create the renderer instance
-    renderer = RichStreamRenderer(
-        working_console.original_console if isinstance(working_console, CapturingConsole) else working_console,
-        cfg=renderer_cfg,
-        verbose=verbose,
+    factory = make_verbose_renderer if verbose else make_default_renderer
+    factory_options = RendererFactoryOptions(
+        console=renderer_console,
+        cfg_overrides=cfg_overrides,
+        verbose=verbose if factory is make_default_renderer else None,
     )
+    renderer = factory_options.build(factory)
 
     # Link the renderer back to the slash session when running from the palette.
     _register_renderer_with_session(_ctx, renderer)
@@ -1540,17 +1494,19 @@ def _handle_json_view_ambiguity(matches: list[Any]) -> Any:
 
 def _handle_questionary_ambiguity(resource_type: str, ref: str, matches: list[Any]) -> Any:
     """Handle ambiguity using questionary interactive interface."""
-    if not (questionary and os.getenv("TERM") and os.isatty(0) and os.isatty(1)):
+    questionary_module, choice_cls = _load_questionary_module()
+    if not (questionary_module and os.getenv("TERM") and os.isatty(0) and os.isatty(1)):
         raise click.ClickException("Interactive selection not available")
 
     # Escape special characters for questionary
     safe_resource_type = resource_type.replace("{", "{{").replace("}", "}}")
     safe_ref = ref.replace("{", "{{").replace("}", "}}")
 
-    picked_idx = questionary.select(
+    picked_idx = questionary_module.select(
         f"Multiple {safe_resource_type}s match '{safe_ref}'. Pick one:",
         choices=[
-            questionary.Choice(
+            _make_questionary_choice(
+                choice_cls,
                 title=(
                     f"{getattr(m, 'name', '—').replace('{', '{{').replace('}', '}}')} — "
                     f"{getattr(m, 'id', '').replace('{', '{{').replace('}', '}}')}"

glaip_sdk/client/agents.py

@@ -29,6 +29,7 @@ from glaip_sdk.client.run_rendering import (
     AgentRunRenderingManager,
     compute_timeout_seconds,
 )
+from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 from glaip_sdk.config.constants import (
     AGENT_CONFIG_FIELDS,
@@ -1235,9 +1236,6 @@ class AgentClient(BaseClient):
     def runs(self) -> "AgentRunsClient":
         """Get the agent runs client."""
         if self._runs_client is None:
-            # Import here to avoid circular dependency with client.main
-            from glaip_sdk.client.main import _build_shared_config
-
-            shared_config = _build_shared_config(self)
+            shared_config = build_shared_config(self)
             self._runs_client = AgentRunsClient(**shared_config)
         return self._runs_client

glaip_sdk/client/main.py

@@ -10,27 +10,11 @@ from typing import Any
 from glaip_sdk.client.agents import AgentClient
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 from glaip_sdk.models import MCP, Agent, Tool
 
 
-def _build_shared_config(client: BaseClient) -> dict[str, Any]:
-    """Build shared configuration dictionary for sub-clients.
-
-    Args:
-        client: Base client instance.
-
-    Returns:
-        Dictionary with shared configuration.
-    """
-    return {
-        "parent_client": client,
-        "api_url": client.api_url,
-        "api_key": client.api_key,
-        "timeout": client._timeout,
-    }
-
-
 class Client(BaseClient):
     """Main client that composes all specialized clients and shares one HTTP session."""
 
@@ -42,7 +26,7 @@ class Client(BaseClient):
         """
         super().__init__(**kwargs)
         # Share the single httpx.Client + config with sub-clients
-        shared_config = _build_shared_config(self)
+        shared_config = build_shared_config(self)
         self.agents = AgentClient(**shared_config)
         self.tools = ToolClient(**shared_config)
         self.mcps = MCPClient(**shared_config)

glaip_sdk/client/mcps.py

@@ -204,7 +204,17 @@ class MCPClient(BaseClient):
     def get_mcp_tools(self, mcp_id: str) -> list[dict[str, Any]]:
         """Get tools available from an MCP."""
         data = self._request("GET", f"{MCPS_ENDPOINT}{mcp_id}/tools")
-        return data or []
+        if data is None:
+            return []
+        if isinstance(data, list):
+            return data
+        if isinstance(data, dict):
+            if "tools" in data:
+                return data.get("tools", []) or []
+            logger.warning("Unexpected MCP tools response keys %s; returning empty list", list(data.keys()))
+            return []
+        logger.warning("Unexpected MCP tools response type %s; returning empty list", type(data).__name__)
+        return []
 
     def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
         """Test MCP connection using configuration.