glaip-sdk 0.3.0__py3-none-any.whl → 0.4.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 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 import display as cli_display
+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)
@@ -1358,19 +1308,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 +1491,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.

glaip_sdk/client/run_rendering.py

@@ -7,9 +7,9 @@ Authors:
 
 from __future__ import annotations
 
-import io
 import json
 import logging
+from collections.abc import Callable
 from time import monotonic
 from typing import Any
 
@@ -19,8 +19,17 @@ from rich.console import Console as _Console
 from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 from glaip_sdk.utils.client_utils import iter_sse_events
 from glaip_sdk.utils.rendering.models import RunStats
-from glaip_sdk.utils.rendering.renderer import RichStreamRenderer
-from glaip_sdk.utils.rendering.renderer.config import RendererConfig
+from glaip_sdk.utils.rendering.renderer import (
+    RendererFactoryOptions,
+    RichStreamRenderer,
+    make_default_renderer,
+    make_minimal_renderer,
+    make_silent_renderer,
+    make_verbose_renderer,
+)
+from glaip_sdk.utils.rendering.state import TranscriptBuffer
+
+NO_AGENT_RESPONSE_FALLBACK = "No agent response received."
 
 
 def _coerce_to_string(value: Any) -> str:
@@ -36,41 +45,6 @@ def _has_visible_text(value: Any) -> bool:
     return isinstance(value, str) and bool(value.strip())
 
 
-def _update_state_transcript(state: Any, text_value: str) -> bool:
-    """Inject transcript text into renderer state if possible."""
-    if state is None:
-        return False
-
-    updated = False
-
-    if hasattr(state, "final_text") and not _has_visible_text(getattr(state, "final_text", "")):
-        try:
-            state.final_text = text_value
-            updated = True
-        except Exception:
-            pass
-
-    buffer = getattr(state, "buffer", None)
-    if isinstance(buffer, list) and not any(_has_visible_text(item) for item in buffer):
-        buffer.append(text_value)
-        updated = True
-
-    return updated
-
-
-def _update_renderer_transcript(renderer: Any, text_value: str) -> None:
-    """Populate the renderer (or its state) with the supplied text."""
-    state = getattr(renderer, "state", None)
-    if _update_state_transcript(state, text_value):
-        return
-
-    if hasattr(renderer, "final_text") and not _has_visible_text(getattr(renderer, "final_text", "")):
-        try:
-            renderer.final_text = text_value
-        except Exception:
-            pass
-
-
 class AgentRunRenderingManager:
     """Coordinate renderer creation and streaming event handling."""
 
@@ -81,6 +55,7 @@ class AgentRunRenderingManager:
             logger: Optional logger instance, creates default if None
         """
         self._logger = logger or logging.getLogger(__name__)
+        self._buffer_factory = TranscriptBuffer
 
     # --------------------------------------------------------------------- #
     # Renderer setup helpers
@@ -92,17 +67,38 @@ class AgentRunRenderingManager:
         verbose: bool = False,
     ) -> RichStreamRenderer:
         """Create an appropriate renderer based on the supplied spec."""
+        transcript_buffer = self._buffer_factory()
+        base_options = RendererFactoryOptions(console=_Console(), transcript_buffer=transcript_buffer)
         if isinstance(renderer_spec, RichStreamRenderer):
             return renderer_spec
 
         if isinstance(renderer_spec, str):
-            if renderer_spec == "silent":
-                return self._create_silent_renderer()
-            if renderer_spec == "minimal":
-                return self._create_minimal_renderer()
-            return self._create_default_renderer(verbose)
+            lowered = renderer_spec.lower()
+            if lowered == "silent":
+                return self._attach_buffer(base_options.build(make_silent_renderer), transcript_buffer)
+            if lowered == "minimal":
+                return self._attach_buffer(base_options.build(make_minimal_renderer), transcript_buffer)
+            if lowered == "verbose":
+                return self._attach_buffer(base_options.build(make_verbose_renderer), transcript_buffer)
+
+        if verbose:
+            return self._attach_buffer(base_options.build(make_verbose_renderer), transcript_buffer)
 
-        return self._create_default_renderer(verbose)
+        default_options = RendererFactoryOptions(
+            console=_Console(),
+            transcript_buffer=transcript_buffer,
+            verbose=verbose,
+        )
+        return self._attach_buffer(default_options.build(make_default_renderer), transcript_buffer)
+
+    @staticmethod
+    def _attach_buffer(renderer: RichStreamRenderer, buffer: TranscriptBuffer) -> RichStreamRenderer:
+        """Attach a captured transcript buffer to a renderer for later inspection."""
+        try:
+            renderer._captured_transcript_buffer = buffer  # type: ignore[attr-defined]
+        except Exception:
+            pass
+        return renderer
 
     def build_initial_metadata(
         self,
@@ -123,70 +119,6 @@ class AgentRunRenderingManager:
         """Notify renderer that streaming is starting."""
         renderer.on_start(meta)
 
-    def _create_silent_renderer(self) -> RichStreamRenderer:
-        """Create a silent renderer that outputs to a string buffer.
-
-        Returns:
-            RichStreamRenderer configured for silent output.
-        """
-        silent_config = RendererConfig(
-            live=False,
-            persist_live=False,
-            render_thinking=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(file=io.StringIO(), force_terminal=False),
-            cfg=silent_config,
-            verbose=False,
-        )
-
-    def _create_minimal_renderer(self) -> RichStreamRenderer:
-        """Create a minimal renderer with reduced output.
-
-        Returns:
-            RichStreamRenderer configured for minimal output.
-        """
-        minimal_config = RendererConfig(
-            live=False,
-            persist_live=False,
-            render_thinking=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(),
-            cfg=minimal_config,
-            verbose=False,
-        )
-
-    def _create_verbose_renderer(self) -> RichStreamRenderer:
-        """Create a verbose renderer with detailed output.
-
-        Returns:
-            RichStreamRenderer configured for verbose output.
-        """
-        verbose_config = RendererConfig(
-            live=False,
-            append_finished_snapshots=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(),
-            cfg=verbose_config,
-            verbose=True,
-        )
-
-    def _create_default_renderer(self, verbose: bool) -> RichStreamRenderer:
-        """Create the default renderer based on verbosity.
-
-        Args:
-            verbose: Whether to create a verbose renderer.
-
-        Returns:
-            RichStreamRenderer instance.
-        """
-        if verbose:
-            return self._create_verbose_renderer()
-        default_config = RendererConfig()
-        return RichStreamRenderer(console=_Console(), cfg=default_config)
-
     # --------------------------------------------------------------------- #
     # Streaming event handling
     # --------------------------------------------------------------------- #
@@ -382,7 +314,52 @@ class AgentRunRenderingManager:
             return
 
         text_value = _coerce_to_string(text)
-        _update_renderer_transcript(renderer, text_value)
+        state = getattr(renderer, "state", None)
+        if state is None:
+            self._ensure_renderer_text(renderer, text_value)
+            return
+
+        self._ensure_state_final_text(state, text_value)
+        self._ensure_state_buffer(state, text_value)
+
+    def _ensure_renderer_text(self, renderer: RichStreamRenderer, text_value: str) -> None:
+        """Best-effort assignment for renderer.final_text."""
+        if not hasattr(renderer, "final_text"):
+            return
+        current_text = getattr(renderer, "final_text", "")
+        if _has_visible_text(current_text):
+            return
+        self._safe_set_attr(renderer, "final_text", text_value)
+
+    def _ensure_state_final_text(self, state: Any, text_value: str) -> None:
+        """Best-effort assignment for renderer.state.final_text."""
+        current_text = getattr(state, "final_text", "")
+        if _has_visible_text(current_text):
+            return
+        self._safe_set_attr(state, "final_text", text_value)
+
+    def _ensure_state_buffer(self, state: Any, text_value: str) -> None:
+        """Append fallback text to the state buffer when available."""
+        buffer = getattr(state, "buffer", None)
+        if not hasattr(buffer, "append"):
+            return
+        self._safe_append(buffer.append, text_value)
+
+    @staticmethod
+    def _safe_set_attr(target: Any, attr: str, value: str) -> None:
+        """Assign attribute while masking renderer-specific failures."""
+        try:
+            setattr(target, attr, value)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _safe_append(appender: Callable[[str], Any], value: str) -> None:
+        """Invoke append-like functions without leaking renderer errors."""
+        try:
+            appender(value)
+        except Exception:
+            pass
 
     # --------------------------------------------------------------------- #
     # Finalisation helpers
@@ -409,7 +386,9 @@ class AgentRunRenderingManager:
         elif hasattr(renderer, "buffer"):
             buffer_values = renderer.buffer
 
-        if buffer_values is not None:
+        if isinstance(buffer_values, TranscriptBuffer):
+            rendered_text = buffer_values.render()
+        elif buffer_values is not None:
             try:
                 rendered_text = "".join(buffer_values)
             except TypeError:
@@ -420,7 +399,7 @@ class AgentRunRenderingManager:
             self._ensure_renderer_final_content(renderer, fallback_text)
 
         renderer.on_complete(st)
-        return final_text or rendered_text or "No response content received."
+        return final_text or rendered_text or NO_AGENT_RESPONSE_FALLBACK
 
 
 def compute_timeout_seconds(kwargs: dict[str, Any]) -> float:

glaip_sdk/client/shared.py

@@ -0,0 +1,21 @@
+"""Shared helpers for client configuration wiring.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from glaip_sdk.client.base import BaseClient
+
+
+def build_shared_config(client: BaseClient) -> dict[str, Any]:
+    """Return the keyword arguments used to initialize sub-clients."""
+    return {
+        "parent_client": client,
+        "api_url": client.api_url,
+        "api_key": client.api_key,
+        "timeout": client._timeout,
+    }