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

glaip_sdk/cli/update_notifier.py

@@ -6,10 +6,14 @@ Author:
 
 from __future__ import annotations
 
+import importlib
+import logging
 import os
-from collections.abc import Callable
+from collections.abc import Callable, Iterable, Iterator
+from contextlib import contextmanager
 from typing import Any, Literal
 
+import click
 import httpx
 from packaging.version import InvalidVersion, Version
 from rich import box
@@ -17,9 +21,11 @@ from rich.console import Console
 
 from glaip_sdk.branding import (
     ACCENT_STYLE,
+    ERROR_STYLE,
     SUCCESS_STYLE,
     WARNING_STYLE,
 )
+from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.utils import command_hint, format_command_hint
 from glaip_sdk.rich_components import AIPPanel
 
@@ -28,6 +34,8 @@ FetchLatestVersion = Callable[[], str | None]
 PYPI_JSON_URL = "https://pypi.org/pypi/{package}/json"
 DEFAULT_TIMEOUT = 1.5  # seconds
 
+_LOGGER = logging.getLogger(__name__)
+
 
 def _parse_version(value: str) -> Version | None:
     """Parse a version string into a `Version`, returning None on failure."""
@@ -43,13 +51,16 @@ def _fetch_latest_version(package_name: str) -> str | None:
     timeout = httpx.Timeout(DEFAULT_TIMEOUT)
 
     try:
-        with httpx.Client(timeout=timeout) as client:
-            response = client.get(url, headers={"Accept": "application/json"})
-            response.raise_for_status()
-            payload = response.json()
-    except httpx.HTTPError:
+        with _suppress_library_logging():
+            with httpx.Client(timeout=timeout) as client:
+                response = client.get(url, headers={"Accept": "application/json"})
+                response.raise_for_status()
+                payload = response.json()
+    except httpx.HTTPError as exc:
+        _LOGGER.debug("Update check failed: %s", exc, exc_info=True)
         return None
-    except ValueError:
+    except ValueError as exc:
+        _LOGGER.debug("Invalid JSON while checking for updates: %s", exc, exc_info=True)
         return None
 
     info = payload.get("info") if isinstance(payload, dict) else None
@@ -68,6 +79,8 @@ def _build_update_panel(
     current_version: str,
     latest_version: str,
     command_text: str,
+    *,
+    show_command_hint: bool,
 ) -> AIPPanel:
     """Create a Rich panel that prompts the user to update."""
     command_markup = format_command_hint(command_text) or command_text
@@ -75,9 +88,10 @@ def _build_update_panel(
         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"[{ACCENT_STYLE}]Run[/] {command_markup} to install."
+        f"https://pypi.org/project/glaip-sdk/{latest_version}/"
     )
+    if show_command_hint:
+        message += f"\n\n[{ACCENT_STYLE}]Run[/] {command_markup} to install."
     return AIPPanel(
         message,
         title=f"[{SUCCESS_STYLE}]AIP SDK Update[/]",
@@ -97,11 +111,7 @@ def maybe_notify_update(
     slash_command: str | None = None,
     style: Literal["panel", "inline"] = "panel",
 ) -> None:
-    """Check PyPI for a newer version and display a prompt if one exists.
-
-    This function deliberately swallows network errors to avoid impacting CLI
-    startup time when offline or when PyPI is unavailable.
-    """
+    """Check PyPI for a newer version and display a prompt if one exists."""
     if not _should_check_for_updates():
         return
 
@@ -120,18 +130,152 @@ def maybe_notify_update(
         return
 
     active_console = console or Console()
+    should_prompt = _should_prompt_for_action(active_console, ctx)
+
     if style == "inline":
+        if should_prompt:
+            message = (
+                f"[{WARNING_STYLE}]✨ Update[/] "
+                f"{current_version} → {latest_version} "
+                "- choose Update now or Skip to continue."
+            )
+            active_console.print(message)
+            _handle_update_decision(active_console, ctx)
+            return
+
         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)
+        active_console.print(f"[{WARNING_STYLE}]✨ Update[/] {current_version} → {latest_version} - {command_markup}")
         return
 
-    panel = _build_update_panel(current_version, latest_version, command_text)
+    panel = _build_update_panel(
+        current_version,
+        latest_version,
+        command_text,
+        show_command_hint=not should_prompt,
+    )
     active_console.print(panel)
+    if should_prompt:
+        _handle_update_decision(active_console, ctx)
+
+
+def _handle_update_decision(console: Console, ctx: Any) -> None:
+    """Prompt the user to take action on the available update."""
+    choice = _prompt_update_decision(console)
+    if choice == "skip":
+        return
+
+    _run_update_command(console, ctx)
+
+
+def _should_prompt_for_action(console: Console, ctx: Any | None) -> bool:
+    """Return True when we can safely block for interactive input."""
+    if ctx is None or not hasattr(ctx, "invoke"):
+        return False
+
+    is_interactive = getattr(console, "is_interactive", False)
+    if not isinstance(is_interactive, bool) or not is_interactive:
+        return False
+
+    is_terminal = getattr(console, "is_terminal", False)
+    if not isinstance(is_terminal, bool) or not is_terminal:
+        return False
+
+    input_method = getattr(console, "input", None)
+    return callable(input_method)
+
+
+def _prompt_update_decision(console: Console) -> Literal["update", "skip"]:
+    """Ask the user to choose between updating now or skipping."""
+    console.print(
+        f"[{ACCENT_STYLE}]Select an option to continue:[/]\n"
+        f"  [{SUCCESS_STYLE}]1.[/] Update now\n"
+        f"  [{WARNING_STYLE}]2.[/] Skip\n"
+    )
+    console.print("[dim]Press Enter after typing your choice.[/]")
+
+    while True:
+        try:
+            response = console.input("Choice [1/2]: ").strip().lower()
+        except (KeyboardInterrupt, EOFError):
+            console.print(f"\n[{WARNING_STYLE}]Update skipped.[/]")
+            return "skip"
+
+        if response in {"1", "update", "u"}:
+            return "update"
+        if response in {"2", "skip", "s"}:
+            return "skip"
+
+        console.print(f"[{ERROR_STYLE}]Please enter 1 to update now or 2 to skip.[/]")
+
+
+def _run_update_command(console: Console, ctx: Any) -> None:
+    """Invoke the built-in update command and surface any errors."""
+    try:
+        ctx.invoke(update_command)
+    except click.ClickException as exc:
+        exc.show()
+        console.print(f"[{ERROR_STYLE}]Update command exited with an error.[/]")
+    except click.Abort:
+        console.print(f"[{WARNING_STYLE}]Update aborted by user.[/]")
+    except Exception as exc:  # pragma: no cover - defensive guard
+        console.print(f"[{ERROR_STYLE}]Unexpected error while running update: {exc}[/]")
+    else:
+        _refresh_installed_version(console, ctx)
+
+
+@contextmanager
+def _suppress_library_logging(
+    logger_names: Iterable[str] | None = None, *, level: int = logging.WARNING
+) -> Iterator[None]:
+    """Temporarily raise log level for selected libraries during update checks."""
+    names = tuple(logger_names) if logger_names is not None else ("httpx",)
+    captured: list[tuple[logging.Logger, int]] = []
+    try:
+        for name in names:
+            logger = logging.getLogger(name)
+            captured.append((logger, logger.level))
+            logger.setLevel(level)
+        yield
+    finally:
+        for logger, previous_level in captured:
+            logger.setLevel(previous_level)
+
+
+def _refresh_installed_version(console: Console, ctx: Any) -> None:
+    """Reload runtime metadata after an in-process upgrade."""
+    new_version: str | None = None
+
+    try:
+        version_module = importlib.reload(importlib.import_module("glaip_sdk._version"))
+        new_version = getattr(version_module, "__version__", None)
+    except Exception as exc:  # pragma: no cover - defensive guard
+        _LOGGER.debug("Failed to reload glaip_sdk._version: %s", exc, exc_info=True)
+
+    try:
+        branding_module = importlib.import_module("glaip_sdk.branding")
+        if new_version:
+            branding_module.SDK_VERSION = new_version
+    except Exception as exc:  # pragma: no cover - defensive guard
+        _LOGGER.debug("Failed to update branding metadata: %s", exc, exc_info=True)
+
+    session = _get_slash_session(ctx)
+    if session and hasattr(session, "refresh_branding"):
+        try:
+            session.refresh_branding(new_version)
+            return
+        except Exception as exc:  # pragma: no cover - defensive guard
+            _LOGGER.debug("Failed to refresh active slash session: %s", exc, exc_info=True)
+
+    if new_version:
+        console.print(f"[{SUCCESS_STYLE}]CLI now running glaip-sdk {new_version}.[/]")
+
+
+def _get_slash_session(ctx: Any) -> Any | None:
+    """Return active slash session from the Click context if present."""
+    ctx_obj = getattr(ctx, "obj", None)
+    if isinstance(ctx_obj, dict):
+        return ctx_obj.get("_slash_session")
+    return None
 
 
 __all__ = ["maybe_notify_update"]

glaip_sdk/cli/utils.py

@@ -147,9 +147,7 @@ def format_command_hint(
 
     highlighted = f"[{HINT_COMMAND_STYLE}]{command}[/]"
     if description:
-        highlighted += (
-            f"  [{HINT_DESCRIPTION_COLOR}]{description}[/{HINT_DESCRIPTION_COLOR}]"
-        )
+        highlighted += f"  [{HINT_DESCRIPTION_COLOR}]{description}[/{HINT_DESCRIPTION_COLOR}]"
     return highlighted
 
 
@@ -234,7 +232,7 @@ _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)."""
     module = importlib.import_module("glaip_sdk")
-    client_class = cast("type[Client]", getattr(module, "Client"))
+    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 {}
@@ -419,9 +417,7 @@ def _prompt_with_auto_select(
             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
-        )
+        logger.debug("PromptSession init failed (%s); falling back to basic prompt.", exc)
         return _basic_prompt(message, completer)
 
     buffer = session.default_buffer
@@ -447,9 +443,7 @@ def _prompt_with_auto_select(
     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
-        )
+        logger.debug("PromptSession prompt failed (%s); falling back to basic prompt.", exc)
         return _basic_prompt(message, completer)
     finally:
         if handler_attached:
@@ -465,9 +459,7 @@ class _FuzzyCompleter:
     def __init__(self, words: list[str]) -> None:
         self.words = words
 
-    def get_completions(
-        self, document: Any, _complete_event: Any
-    ) -> Any:  # pragma: no cover
+    def get_completions(self, document: Any, _complete_event: Any) -> Any:  # pragma: no cover
         word = document.get_word_before_cursor()
         if not word:
             return
@@ -492,9 +484,7 @@ class _FuzzyCompleter:
         return False
 
 
-def _perform_fuzzy_search(
-    answer: str, labels: list[str], by_label: dict[str, dict[str, Any]]
-) -> dict[str, Any] | None:
+def _perform_fuzzy_search(answer: str, labels: list[str], by_label: dict[str, dict[str, Any]]) -> dict[str, Any] | None:
     """Perform fuzzy search fallback and return best match."""
     # Exact label match
     if answer in by_label:
@@ -615,7 +605,7 @@ def _coerce_result_payload(result: Any) -> Any:
 
 
 def _ensure_displayable(payload: Any) -> Any:
-    if isinstance(payload, dict | list | str | int | float | bool) or payload is None:
+    if isinstance(payload, (dict, list, str, int, float, bool)) or payload is None:
         return payload
 
     if hasattr(payload, "__dict__"):
@@ -686,9 +676,7 @@ def output_result(
 # _PICK_THRESHOLD = int(os.getenv("AIP_PICK_THRESHOLD", "5") or "5")
 
 
-def _normalise_rows(
-    items: list[Any], transform_func: Callable[[Any], dict[str, Any]] | None
-) -> list[dict[str, Any]]:
+def _normalise_rows(items: list[Any], transform_func: Callable[[Any], dict[str, Any]] | None) -> list[dict[str, Any]]:
     try:
         rows: list[dict[str, Any]] = []
         for item in items:
@@ -707,9 +695,7 @@ def _normalise_rows(
         return []
 
 
-def _render_plain_list(
-    rows: list[dict[str, Any]], title: str, columns: list[tuple]
-) -> None:
+def _render_plain_list(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
     if not rows:
         click.echo(f"No {title.lower()} found.")
         return
@@ -718,9 +704,7 @@ def _render_plain_list(
         click.echo(row_str)
 
 
-def _render_markdown_list(
-    rows: list[dict[str, Any]], title: str, columns: list[tuple]
-) -> None:
+def _render_markdown_list(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
     if not rows:
         click.echo(f"No {title.lower()} found.")
         return
@@ -748,9 +732,7 @@ def _create_table(columns: list[tuple[str, str, str, int | None]], title: str) -
     return table
 
 
-def _build_table_group(
-    rows: list[dict[str, Any]], columns: list[tuple], title: str
-) -> Group:
+def _build_table_group(rows: list[dict[str, Any]], columns: list[tuple], title: str) -> Group:
     table = _create_table(columns, title)
     for row in rows:
         table.add_row(*[str(row.get(key, "N/A")) for key, _, _, _ in columns])
@@ -760,24 +742,16 @@ def _build_table_group(
 
 def _handle_json_output(items: list[Any], rows: list[dict[str, Any]]) -> None:
     """Handle JSON output format."""
-    data = (
-        rows
-        if rows
-        else [it.to_dict() if hasattr(it, "to_dict") else it for it in items]
-    )
+    data = rows if rows else [it.to_dict() if hasattr(it, "to_dict") else it for it in items]
     click.echo(json.dumps(data, indent=2, default=str))
 
 
-def _handle_plain_output(
-    rows: list[dict[str, Any]], title: str, columns: list[tuple]
-) -> None:
+def _handle_plain_output(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
     """Handle plain text output format."""
     _render_plain_list(rows, title, columns)
 
 
-def _handle_markdown_output(
-    rows: list[dict[str, Any]], title: str, columns: list[tuple]
-) -> None:
+def _handle_markdown_output(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
     """Handle markdown output format."""
     _render_markdown_list(rows, title, columns)
 
@@ -792,9 +766,7 @@ def _should_use_fuzzy_picker() -> bool:
     return console.is_terminal and os.isatty(1)
 
 
-def _try_fuzzy_pick(
-    rows: list[dict[str, Any]], columns: list[tuple], title: str
-) -> dict[str, Any] | None:
+def _try_fuzzy_pick(rows: list[dict[str, Any]], columns: list[tuple], title: str) -> dict[str, Any] | None:
     """Best-effort fuzzy selection; returns None if the picker fails."""
     if not _should_use_fuzzy_picker():
         return None
@@ -825,14 +797,10 @@ def _print_selection_tip(title: str) -> None:
     """Print the contextual follow-up tip after a fuzzy selection."""
     tip_cmd = _resource_tip_command(title)
     if tip_cmd:
-        console.print(
-            markup_text(f"\n[dim]Tip: use `{tip_cmd} <ID>` for details[/dim]")
-        )
+        console.print(markup_text(f"\n[dim]Tip: use `{tip_cmd} <ID>` for details[/dim]"))
 
 
-def _handle_fuzzy_pick_selection(
-    rows: list[dict[str, Any]], columns: list[tuple], title: str
-) -> bool:
+def _handle_fuzzy_pick_selection(rows: list[dict[str, Any]], columns: list[tuple], title: str) -> bool:
     """Handle fuzzy picker selection, returns True if selection was made."""
     picked = _try_fuzzy_pick(rows, columns, title)
     if picked is None:
@@ -855,9 +823,7 @@ def _handle_table_output(
     """Handle table output with paging."""
     content = _build_table_group(rows, columns, title)
     should_page = (
-        pager._should_page_output(len(rows), console.is_terminal and os.isatty(1))
-        if use_pager is None
-        else use_pager
+        pager._should_page_output(len(rows), console.is_terminal and os.isatty(1)) if use_pager is None else use_pager
     )
 
     if should_page:
@@ -982,7 +948,6 @@ def build_renderer(
         theme=theme,
         style=style,
         live=live_enabled,
-        show_delegate_tool_panels=False,
         append_finished_snapshots=bool(snapshots)
         if snapshots is not None
         else RendererConfig.append_finished_snapshots,
@@ -990,9 +955,7 @@ def build_renderer(
 
     # Create the renderer instance
     renderer = RichStreamRenderer(
-        working_console.original_console
-        if isinstance(working_console, CapturingConsole)
-        else working_console,
+        working_console.original_console if isinstance(working_console, CapturingConsole) else working_console,
         cfg=renderer_cfg,
         verbose=verbose,
     )
@@ -1080,22 +1043,14 @@ def _resolve_by_name_multiple_with_select(matches: list[Any], select: int) -> An
     return matches[idx]
 
 
-def _resolve_by_name_multiple_fuzzy(
-    ctx: Any, ref: str, matches: list[Any], label: str
-) -> Any:
+def _resolve_by_name_multiple_fuzzy(ctx: Any, ref: str, matches: list[Any], label: str) -> Any:
     """Resolve multiple matches preferring the fuzzy picker interface."""
-    return handle_ambiguous_resource(
-        ctx, label.lower(), ref, matches, interface_preference="fuzzy"
-    )
+    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:
+def _resolve_by_name_multiple_questionary(ctx: Any, ref: str, matches: list[Any], label: str) -> Any:
     """Resolve multiple matches preferring the questionary interface."""
-    return handle_ambiguous_resource(
-        ctx, label.lower(), ref, matches, interface_preference="questionary"
-    )
+    return handle_ambiguous_resource(ctx, label.lower(), ref, matches, interface_preference="questionary")
 
 
 def resolve_resource(
@@ -1140,9 +1095,7 @@ def resolve_resource(
         raise click.ClickException(f"{label} '{ref}' not found")
 
     # Find resources by name
-    _spinner_update(
-        spinner, f"[bold blue]Searching {label}s matching '{ref}'…[/bold blue]"
-    )
+    _spinner_update(spinner, f"[bold blue]Searching {label}s matching '{ref}'…[/bold blue]")
     matches = find_by_name(name=ref)
     if not matches:
         _spinner_stop(spinner)
@@ -1173,9 +1126,7 @@ def _handle_json_view_ambiguity(matches: list[Any]) -> Any:
     return matches[0]
 
 
-def _handle_questionary_ambiguity(
-    resource_type: str, ref: str, 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)):
         raise click.ClickException("Interactive selection not available")
@@ -1188,7 +1139,10 @@ def _handle_questionary_ambiguity(
         f"Multiple {safe_resource_type}s match '{safe_ref}'. Pick one:",
         choices=[
             questionary.Choice(
-                title=f"{getattr(m, 'name', '—').replace('{', '{{').replace('}', '}}')} — {getattr(m, 'id', '').replace('{', '{{').replace('}', '}}')}",
+                title=(
+                    f"{getattr(m, 'name', '—').replace('{', '{{').replace('}', '}}')} — "
+                    f"{getattr(m, 'id', '').replace('{', '{{').replace('}', '}}')}"
+                ),
                 value=i,
             )
             for i, m in enumerate(matches)
@@ -1202,19 +1156,13 @@ def _handle_questionary_ambiguity(
     return matches[picked_idx]
 
 
-def _handle_fallback_numeric_ambiguity(
-    resource_type: str, ref: str, matches: list[Any]
-) -> Any:
+def _handle_fallback_numeric_ambiguity(resource_type: str, ref: str, matches: list[Any]) -> Any:
     """Handle ambiguity using numeric prompt fallback."""
     # Escape special characters for display
     safe_resource_type = resource_type.replace("{", "{{").replace("}", "}}")
     safe_ref = ref.replace("{", "{{").replace("}", "}}")
 
-    console.print(
-        markup_text(
-            f"[{WARNING_STYLE}]Multiple {safe_resource_type}s found matching '{safe_ref}':[/]"
-        )
-    )
+    console.print(markup_text(f"[{WARNING_STYLE}]Multiple {safe_resource_type}s found matching '{safe_ref}':[/]"))
     table = AIPTable(
         title=f"Select {safe_resource_type.title()}",
     )
@@ -1229,8 +1177,8 @@ def _handle_fallback_numeric_ambiguity(
     )
     try:
         choice = int(choice_str)
-    except ValueError:
-        raise click.ClickException("Invalid selection")
+    except ValueError as err:
+        raise click.ClickException("Invalid selection") from err
     if 1 <= choice <= len(matches):
         return matches[choice - 1]
     raise click.ClickException("Invalid selection")

glaip_sdk/cli/validators.py

@@ -42,7 +42,7 @@ def validate_agent_name_cli(name: str) -> str:
     try:
         return validate_agent_name(name)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_agent_instruction_cli(instruction: str) -> str:
@@ -60,7 +60,7 @@ def validate_agent_instruction_cli(instruction: str) -> str:
     try:
         return validate_agent_instruction(instruction)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_timeout_cli(timeout: int) -> int:
@@ -78,7 +78,7 @@ def validate_timeout_cli(timeout: int) -> int:
     try:
         return validate_timeout(timeout)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_tool_name_cli(name: str) -> str:
@@ -96,7 +96,7 @@ def validate_tool_name_cli(name: str) -> str:
     try:
         return validate_tool_name(name)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_mcp_name_cli(name: str) -> str:
@@ -114,7 +114,7 @@ def validate_mcp_name_cli(name: str) -> str:
     try:
         return validate_mcp_name(name)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_file_path_cli(file_path: str | Path, must_exist: bool = True) -> Path:
@@ -133,7 +133,7 @@ def validate_file_path_cli(file_path: str | Path, must_exist: bool = True) -> Pa
     try:
         return validate_file_path(file_path, must_exist)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_directory_path_cli(dir_path: str | Path, must_exist: bool = True) -> Path:
@@ -152,7 +152,7 @@ def validate_directory_path_cli(dir_path: str | Path, must_exist: bool = True) -
     try:
         return validate_directory_path(dir_path, must_exist)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_url_cli(url: str) -> str:
@@ -170,7 +170,7 @@ def validate_url_cli(url: str) -> str:
     try:
         return validate_url(url)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_api_key_cli(api_key: str) -> str:
@@ -188,7 +188,7 @@ def validate_api_key_cli(api_key: str) -> str:
     try:
         return validate_api_key(api_key)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def coerce_timeout_cli(value: int | float | str) -> int:
@@ -206,7 +206,7 @@ def coerce_timeout_cli(value: int | float | str) -> int:
     try:
         return coerce_timeout(value)
     except ValueError as e:
-        raise click.ClickException(str(e))
+        raise click.ClickException(str(e)) from e
 
 
 def validate_name_uniqueness_cli(
@@ -230,8 +230,7 @@ def validate_name_uniqueness_cli(
         existing = finder_func(name=name)
         if existing:
             raise click.ClickException(
-                f"A {resource_type.lower()} named '{name}' already exists. "
-                "Please choose a unique name."
+                f"A {resource_type.lower()} named '{name}' already exists. Please choose a unique name."
             )
     except click.ClickException:
         raise