glaip-sdk 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

glaip_sdk/cli/slash/session.py

@@ -29,6 +29,7 @@ from .prompt import (
     Style,
     patch_stdout,
     setup_prompt_toolkit,
+    to_formatted_text,
 )
 
 SlashHandler = Callable[["SlashSession", list[str], bool], bool]
@@ -61,6 +62,8 @@ class SlashSession:
         self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
         self._config_cache: dict[str, Any] | None = None
         self._welcome_rendered = False
+        self._verbose_enabled = False
+        self._active_renderer: Any | None = None
 
         self._home_placeholder = "Start with / to browse commands"
 
@@ -73,6 +76,8 @@ class SlashSession:
         self._setup_prompt_toolkit()
         self._register_defaults()
         self._branding = AIPBranding.create_from_sdk()
+        self._suppress_login_layout = False
+        self._default_actions_shown = False
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -93,7 +98,9 @@ class SlashSession:
         if not self._ensure_configuration():
             return
 
-        self._render_header(initial=True)
+        self._render_header(initial=not self._welcome_rendered)
+        if not self._default_actions_shown:
+            self._show_default_quick_actions()
         self._render_home_hint()
         self._run_interactive_loop()
 
@@ -151,6 +158,7 @@ class SlashSession:
             self.console.print(
                 "[yellow]Configuration required.[/] Launching `/login` wizard..."
             )
+            self._suppress_login_layout = True
             try:
                 self._cmd_login([], False)
             except KeyboardInterrupt:
@@ -158,6 +166,8 @@ class SlashSession:
                     "[red]Configuration aborted. Closing the command palette.[/red]"
                 )
                 return False
+            finally:
+                self._suppress_login_layout = False
 
         return True
 
@@ -209,58 +219,60 @@ class SlashSession:
     def _cmd_help(self, _args: list[str], invoked_from_agent: bool) -> bool:
         try:
             if invoked_from_agent:
-                table = Table(title="Agent Context")
-                table.add_column("Input", style="cyan", no_wrap=True)
-                table.add_column("What happens", style="green")
-                table.add_row(
-                    "<message>", "Run the active agent once with that prompt."
-                )
-                table.add_row("/details", "Show the full agent export and metadata.")
-                table.add_row(
-                    self.STATUS_COMMAND, "Display connection status without leaving."
-                )
-                table.add_row("/exit (/back)", "Return to the slash home screen.")
-                table.add_row("/help (/?)", "Display this context-aware menu.")
-                self.console.print(table)
-                if self.last_run_input:
-                    self.console.print(f"[dim]Last run input:[/] {self.last_run_input}")
-                self.console.print(
-                    "[dim]Global commands (e.g. `/login`, `/status`) remain available inside the agent prompt.[/dim]"
-                )
+                self._render_agent_help()
             else:
-                table = Table(title="Slash Commands")
-                table.add_column("Command", style="cyan", no_wrap=True)
-                table.add_column("Description", style="green")
-
-                for cmd in sorted(self._unique_commands.values(), key=lambda c: c.name):
-                    aliases = ", ".join(f"/{alias}" for alias in cmd.aliases if alias)
-                    verb = f"/{cmd.name}"
-                    if aliases:
-                        verb = f"{verb} ({aliases})"
-                    table.add_row(verb, cmd.help)
-
-                self.console.print(table)
-                self.console.print(
-                    "[dim]Tip: `{self.AGENTS_COMMAND}` lets you jump into an agent run prompt quickly.[/dim]"
-                )
+                self._render_global_help()
         except Exception as exc:  # pragma: no cover - UI/display errors
             self.console.print(f"[red]Error displaying help: {exc}[/red]")
             return False
 
         return True
 
+    def _render_agent_help(self) -> None:
+        table = Table(title="Agent Context")
+        table.add_column("Input", style="cyan", no_wrap=True)
+        table.add_column("What happens", style="green")
+        table.add_row("<message>", "Run the active agent once with that prompt.")
+        table.add_row("/details", "Show the full agent export and metadata.")
+        table.add_row(self.STATUS_COMMAND, "Display connection status without leaving.")
+        table.add_row("/verbose", "Toggle verbose streaming output (Ctrl+T works too).")
+        table.add_row("/exit (/back)", "Return to the slash home screen.")
+        table.add_row("/help (/?)", "Display this context-aware menu.")
+        self.console.print(table)
+        if self.last_run_input:
+            self.console.print(f"[dim]Last run input:[/] {self.last_run_input}")
+        self.console.print(
+            "[dim]Global commands (e.g. `/login`, `/status`) remain available inside the agent prompt.[/dim]"
+        )
+
+    def _render_global_help(self) -> None:
+        table = Table(title="Slash Commands")
+        table.add_column("Command", style="cyan", no_wrap=True)
+        table.add_column("Description", style="green")
+
+        for cmd in sorted(self._unique_commands.values(), key=lambda c: c.name):
+            aliases = ", ".join(f"/{alias}" for alias in cmd.aliases if alias)
+            verb = f"/{cmd.name}"
+            if aliases:
+                verb = f"{verb} ({aliases})"
+            table.add_row(verb, cmd.help)
+
+        self.console.print(table)
+        self.console.print(
+            "[dim]Tip: `{self.AGENTS_COMMAND}` lets you jump into an agent run prompt quickly.[/dim]"
+        )
+
     def _cmd_login(self, _args: list[str], _invoked_from_agent: bool) -> bool:
         self.console.print("[cyan]Launching configuration wizard...[/cyan]")
         try:
             self.ctx.invoke(configure_command)
             self._config_cache = None
-            self._render_header(initial=True)
-            self._show_quick_actions(
-                [
-                    (self.STATUS_COMMAND, "Verify the connection"),
-                    (self.AGENTS_COMMAND, "Pick an agent to inspect or run"),
-                ]
-            )
+            if self._suppress_login_layout:
+                self._welcome_rendered = False
+                self._default_actions_shown = False
+            else:
+                self._render_header(initial=True)
+                self._show_default_quick_actions()
         except click.ClickException as exc:
             self.console.print(f"[red]{exc}[/red]")
         return True
@@ -343,7 +355,7 @@ class SlashSession:
             # running.
             return True
 
-        self.console.print("[cyan]Closing the command palette.")
+        self.console.print("[cyan]Closing the command palette.[/cyan]")
         return False
 
     # ------------------------------------------------------------------
@@ -388,12 +400,119 @@ class SlashSession:
                 aliases=("q",),
             )
         )
+        self._register(
+            SlashCommand(
+                name="verbose",
+                help="Toggle verbose streaming output.",
+                handler=SlashSession._cmd_verbose,
+            )
+        )
 
     def _register(self, command: SlashCommand) -> None:
         self._unique_commands[command.name] = command
         for key in (command.name, *command.aliases):
             self._commands[key] = command
 
+    # ------------------------------------------------------------------
+    # Verbose mode helpers
+    # ------------------------------------------------------------------
+    @property
+    def verbose_enabled(self) -> bool:
+        """Return whether verbose agent runs are enabled."""
+
+        return self._verbose_enabled
+
+    def set_verbose(self, enabled: bool, *, announce: bool = True) -> None:
+        """Enable or disable verbose mode with optional announcement."""
+
+        if self._verbose_enabled == enabled:
+            if announce:
+                self._print_verbose_status(context="already")
+            return
+
+        self._verbose_enabled = enabled
+        self._sync_active_renderer()
+        if announce:
+            self._print_verbose_status(context="changed")
+
+    def toggle_verbose(self, *, announce: bool = True) -> None:
+        """Flip verbose mode state."""
+
+        self.set_verbose(not self._verbose_enabled, announce=announce)
+
+    def _cmd_verbose(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Slash handler for `/verbose` command."""
+
+        if args:
+            self.console.print(
+                "Usage: `/verbose` toggles verbose streaming output. Press Ctrl+T as a shortcut."
+            )
+        else:
+            self.toggle_verbose()
+
+        return True
+
+    def _print_verbose_status(self, *, context: str) -> None:
+        state_word = "on" if self._verbose_enabled else "off"
+        if context == "already":
+            self.console.print(
+                f"Verbose mode already {state_word}. Use Ctrl+T or `/verbose` to toggle."
+            )
+            return
+
+        change_word = "enabled" if self._verbose_enabled else "disabled"
+        self.console.print(
+            f"Verbose mode {change_word}. Use Ctrl+T or `/verbose` to toggle."
+        )
+
+    # ------------------------------------------------------------------
+    # Agent run coordination helpers
+    # ------------------------------------------------------------------
+    def register_active_renderer(self, renderer: Any) -> None:
+        """Register the renderer currently streaming an agent run."""
+
+        self._active_renderer = renderer
+        self._sync_active_renderer()
+
+    def clear_active_renderer(self, renderer: Any | None = None) -> None:
+        """Clear the active renderer if it matches the provided instance."""
+
+        if renderer is not None and renderer is not self._active_renderer:
+            return
+        self._active_renderer = None
+
+    def notify_agent_run_started(self) -> None:
+        """Mark that an agent run is in progress."""
+
+        self.clear_active_renderer()
+
+    def notify_agent_run_finished(self) -> None:
+        """Mark that the active agent run has completed."""
+
+        self.clear_active_renderer()
+
+    def _sync_active_renderer(self) -> None:
+        """Ensure the active renderer reflects the current verbose state."""
+
+        renderer = self._active_renderer
+        if renderer is None:
+            return
+
+        applied = False
+        apply_verbose = getattr(renderer, "apply_verbosity", None)
+        if callable(apply_verbose):
+            try:
+                apply_verbose(self._verbose_enabled)
+                applied = True
+            except Exception:
+                pass
+
+        if not applied and hasattr(renderer, "verbose"):
+            try:
+                renderer.verbose = self._verbose_enabled
+            except Exception:
+                pass
+
     def _parse(self, raw: str) -> tuple[str, list[str]]:
         try:
             tokens = shlex.split(raw)
@@ -416,33 +535,83 @@ class SlashSession:
         match = get_close_matches(verb, keys, n=1)
         return match[0] if match else None
 
-    def _prompt(self, message: str, *, placeholder: str | None = None) -> str:
-        if self._ptk_session and self._ptk_style and patch_stdout:
-            with patch_stdout():  # pragma: no cover - UI specific
-                prompt_text = (
-                    FormattedText([("class:prompt", message)])
-                    if FormattedText is not None
-                    else message
-                )
-                prompt_kwargs: dict[str, Any] = {"style": self._ptk_style}
-                if placeholder:
-                    placeholder_text = (
-                        FormattedText([("class:placeholder", placeholder)])
-                        if FormattedText is not None
-                        else placeholder
-                    )
-                    prompt_kwargs["placeholder"] = placeholder_text
-                try:
-                    return self._ptk_session.prompt(prompt_text, **prompt_kwargs)
-                except (
-                    TypeError
-                ):  # pragma: no cover - compatibility with older prompt_toolkit
-                    prompt_kwargs.pop("placeholder", None)
-                    return self._ptk_session.prompt(prompt_text, **prompt_kwargs)
+    def _convert_message(self, value: Any) -> Any:
+        """Convert a message value to the appropriate format for display."""
+        if FormattedText is not None and to_formatted_text is not None:
+            return to_formatted_text(value)
+        if FormattedText is not None:
+            return FormattedText([("class:prompt", str(value))])
+        return str(value)
+
+    def _get_prompt_kwargs(self, placeholder: str | None) -> dict[str, Any]:
+        """Get prompt kwargs with optional placeholder styling."""
+        prompt_kwargs: dict[str, Any] = {"style": self._ptk_style}
+        if placeholder:
+            placeholder_text = (
+                FormattedText([("class:placeholder", placeholder)])
+                if FormattedText is not None
+                else placeholder
+            )
+            prompt_kwargs["placeholder"] = placeholder_text
+        return prompt_kwargs
+
+    def _prompt_with_prompt_toolkit(
+        self, message: str | Callable[[], Any], placeholder: str | None
+    ) -> str:
+        """Handle prompting with prompt_toolkit."""
+        with patch_stdout():  # pragma: no cover - UI specific
+            if callable(message):
+
+                def prompt_text() -> Any:
+                    return self._convert_message(message())
+            else:
+                prompt_text = self._convert_message(message)
+
+            prompt_kwargs = self._get_prompt_kwargs(placeholder)
 
+            try:
+                return self._ptk_session.prompt(prompt_text, **prompt_kwargs)
+            except (
+                TypeError
+            ):  # pragma: no cover - compatibility with older prompt_toolkit
+                prompt_kwargs.pop("placeholder", None)
+                return self._ptk_session.prompt(prompt_text, **prompt_kwargs)
+
+    def _extract_message_text(self, raw_value: Any) -> str:
+        """Extract text content from various message formats."""
+        if isinstance(raw_value, str):
+            return raw_value
+
+        try:
+            if FormattedText is not None and isinstance(raw_value, FormattedText):
+                return "".join(text for _style, text in raw_value)
+            elif isinstance(raw_value, list):
+                return "".join(segment[1] for segment in raw_value)
+            else:
+                return str(raw_value)
+        except Exception:
+            return str(raw_value)
+
+    def _prompt_with_basic_input(
+        self, message: str | Callable[[], Any], placeholder: str | None
+    ) -> str:
+        """Handle prompting with basic input."""
         if placeholder:
             self.console.print(f"[dim]{placeholder}[/dim]")
-        return input(message)
+
+        raw_value = message() if callable(message) else message
+        actual_message = self._extract_message_text(raw_value)
+
+        return input(actual_message)
+
+    def _prompt(
+        self, message: str | Callable[[], Any], *, placeholder: str | None = None
+    ) -> str:
+        """Main prompt function with reduced complexity."""
+        if self._ptk_session and self._ptk_style and patch_stdout:
+            return self._prompt_with_prompt_toolkit(message, placeholder)
+
+        return self._prompt_with_basic_input(message, placeholder)
 
     def _get_client(self) -> Any:  # type: ignore[no-any-return]
         if self._client is None:
@@ -503,12 +672,17 @@ class SlashSession:
         agent_type = getattr(active_agent, "type", "") or "-"
         description = getattr(active_agent, "description", "") or ""
 
+        verbose_label = "verbose on" if self._verbose_enabled else "verbose off"
+
         header_grid = Table.grid(expand=True)
         header_grid.add_column(ratio=3)
         header_grid.add_column(ratio=1, justify="right")
 
         primary_line = f"[bold]{agent_name}[/bold] · [dim]{agent_type}[/dim] · [cyan]{agent_id}[/cyan]"
-        header_grid.add_row(primary_line, "[green]ready[/green]")
+        header_grid.add_row(
+            primary_line,
+            f"[green]ready[/green] · {verbose_label}",
+        )
 
         if description:
             header_grid.add_row(f"[dim]{description}[/dim]", "")
@@ -517,10 +691,12 @@ class SlashSession:
         keybar.add_column(justify="left")
         keybar.add_column(justify="left")
         keybar.add_column(justify="left")
+        keybar.add_column(justify="left")
         keybar.add_row(
             "[bold]/help[/bold] [dim]Show commands[/dim]",
             "[bold]/details[/bold] [dim]Agent config[/dim]",
             "[bold]/exit[/bold] [dim]Back[/dim]",
+            "[bold]Ctrl+T[/bold] [dim]Toggle verbose[/dim]",
         )
 
         header_grid.add_row(keybar, "")
@@ -544,6 +720,8 @@ class SlashSession:
                 "",
                 f"[dim]API URL[/dim]: {api_url or 'Not configured'}",
                 f"[dim]Credentials[/dim]: {status}",
+                f"[dim]Verbose mode[/dim]: {'on' if self._verbose_enabled else 'off'}",
+                "[dim]Tip[/dim]: Press Ctrl+T or run `/verbose` to toggle verbose streaming.",
             ]
             extra: list[str] = []
             self._add_agent_info_to_header(extra, active_agent)
@@ -560,8 +738,10 @@ class SlashSession:
         status_bar.add_row(
             "[bold cyan]AIP Palette[/bold cyan]",
             f"[dim]API[/dim]: {api_url or 'Not configured'}",
-            "[dim]Type /help for shortcuts[/dim]",
+            f"[dim]Verbose[/dim]: {'on' if self._verbose_enabled else 'off'}",
         )
+        status_bar.add_row("[dim]Ctrl+T toggles verbose[/dim]", "", "")
+        status_bar.add_row("[dim]Type /help for shortcuts[/dim]", "", "")
 
         if active_agent is not None:
             agent_id = str(getattr(active_agent, "id", ""))
@@ -598,10 +778,20 @@ class SlashSession:
             label = recent.get("name") or recent.get("id") or "-"
             lines.append(f"[dim]Recent agent[/dim]: {label} [{recent.get('id', '-')}]")
 
+    def _show_default_quick_actions(self) -> None:
+        self._show_quick_actions(
+            [
+                (self.STATUS_COMMAND, "Verify the connection"),
+                (self.AGENTS_COMMAND, "Pick an agent to inspect or run"),
+            ]
+        )
+        self._default_actions_shown = True
+
     def _render_home_hint(self) -> None:
         self.console.print(
             AIPPanel(
                 "Type `/help` for command palette commands, `/agents` to browse agents, or `/exit` (`/q`) to leave the palette.\n"
+                "Press Ctrl+T to toggle verbose output.\n"
                 "Press Ctrl+C to cancel the current entry, Ctrl+D to quit immediately.",
                 title="✨ Getting Started",
                 border_style="cyan",

glaip_sdk/cli/update_notifier.py

@@ -0,0 +1,107 @@
+"""Utility helpers for checking and displaying SDK update notifications.
+
+Author:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+
+import httpx
+from packaging.version import InvalidVersion, Version
+from rich.console import Console
+
+from glaip_sdk.rich_components import AIPPanel
+
+FetchLatestVersion = Callable[[], str | None]
+
+PYPI_JSON_URL = "https://pypi.org/pypi/{package}/json"
+DEFAULT_TIMEOUT = 1.5  # seconds
+
+
+def _parse_version(value: str) -> Version | None:
+    """Parse a version string into a `Version`, returning None on failure."""
+    try:
+        return Version(value)
+    except InvalidVersion:
+        return None
+
+
+def _fetch_latest_version(package_name: str) -> str | None:
+    """Fetch the latest published version from PyPI."""
+    url = PYPI_JSON_URL.format(package=package_name)
+    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:
+        return None
+    except ValueError:
+        return None
+
+    info = payload.get("info") if isinstance(payload, dict) else None
+    latest_version = info.get("version") if isinstance(info, dict) else None
+    if isinstance(latest_version, str) and latest_version.strip():
+        return latest_version.strip()
+    return None
+
+
+def _should_check_for_updates() -> bool:
+    """Return False when update checks are explicitly disabled."""
+    return os.getenv("AIP_NO_UPDATE_CHECK") is None
+
+
+def _build_update_panel(
+    current_version: str,
+    latest_version: str,
+) -> AIPPanel:
+    """Create a Rich panel that prompts the user to update."""
+    message = (
+        f"[bold yellow]✨ Update available![/bold yellow] "
+        f"{current_version} → {latest_version}\n\n"
+        "See the latest release notes:\n"
+        f"https://pypi.org/project/glaip-sdk/{latest_version}/\n\n"
+        "[cyan]Run[/cyan] [bold]aip update[/bold] to install."
+    )
+    return AIPPanel(
+        message,
+        title="[bold green]AIP SDK Update[/bold green]",
+    )
+
+
+def maybe_notify_update(
+    current_version: str,
+    *,
+    package_name: str = "glaip-sdk",
+    console: Console | None = None,
+    fetch_latest_version: FetchLatestVersion | None = None,
+) -> 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.
+    """
+    if not _should_check_for_updates():
+        return
+
+    fetcher = fetch_latest_version or (lambda: _fetch_latest_version(package_name))
+    latest_version = fetcher()
+    if not latest_version:
+        return
+
+    current = _parse_version(current_version)
+    latest = _parse_version(latest_version)
+    if current is None or latest is None or latest <= current:
+        return
+
+    active_console = console or Console()
+    panel = _build_update_panel(current_version, latest_version)
+    active_console.print(panel)
+
+
+__all__ = ["maybe_notify_update"]

glaip_sdk/cli/utils.py

@@ -828,7 +828,7 @@ def _build_table_group(
     table = _create_table(columns, title)
     for row in rows:
         table.add_row(*[str(row.get(key, "N/A")) for key, _, _, _ in columns])
-    footer = Text(f"\n[dim]Total {len(rows)} items[/dim]")
+    footer = Text.from_markup(f"\n[dim]Total {len(rows)} items[/dim]")
     return Group(table, footer)
 
 
@@ -872,7 +872,7 @@ def _handle_markdown_output(
 
 def _handle_empty_items(title: str) -> None:
     """Handle case when no items are found."""
-    console.print(Text(f"[yellow]No {title.lower()} found.[/yellow]"))
+    console.print(Text.from_markup(f"[yellow]No {title.lower()} found.[/yellow]"))
 
 
 def _should_use_fuzzy_picker() -> bool:
@@ -916,7 +916,9 @@ def _print_selection_tip(title: str) -> None:
     """Print the contextual follow-up tip after a fuzzy selection."""
 
     tip_cmd = _resource_tip_command(title)
-    console.print(Text(f"\n[dim]Tip: use `{tip_cmd} <ID>` for details[/dim]"))
+    console.print(
+        Text.from_markup(f"\n[dim]Tip: use `{tip_cmd} <ID>` for details[/dim]")
+    )
 
 
 def _handle_fuzzy_pick_selection(
@@ -936,11 +938,21 @@ def _handle_fuzzy_pick_selection(
 
 
 def _handle_table_output(
-    rows: list[dict[str, Any]], columns: list[tuple], title: str
+    rows: list[dict[str, Any]],
+    columns: list[tuple],
+    title: str,
+    *,
+    use_pager: bool | None = None,
 ) -> None:
     """Handle table output with paging."""
     content = _build_table_group(rows, columns, title)
-    if _should_page_output(len(rows), console.is_terminal and os.isatty(1)):
+    should_page = (
+        _should_page_output(len(rows), console.is_terminal and os.isatty(1))
+        if use_pager is None
+        else use_pager
+    )
+
+    if should_page:
         ansi = _render_ansi(content)
         if not _page_with_system_pager(ansi):
             with console.pager(styles=True):
@@ -955,8 +967,11 @@ def output_list(
     title: str,
     columns: list[tuple[str, str, str, int | None]],
     transform_func: Callable | None = None,
+    *,
+    skip_picker: bool = False,
+    use_pager: bool | None = None,
 ) -> None:
-    """Display a list with fuzzy palette by default on TTY, Rich table as fallback."""
+    """Display a list with optional fuzzy palette for quick selection."""
     fmt = _get_view(ctx)
     rows = _normalise_rows(items, transform_func)
     rows = _mask_rows_if_configured(rows)
@@ -983,10 +998,10 @@ def output_list(
         except Exception:
             pass
 
-    if _handle_fuzzy_pick_selection(rows, columns, title):
+    if not skip_picker and _handle_fuzzy_pick_selection(rows, columns, title):
         return
 
-    _handle_table_output(rows, columns, title)
+    _handle_table_output(rows, columns, title, use_pager=use_pager)
 
 
 # ------------------------- Output flags decorator ------------------------ #
@@ -1108,6 +1123,17 @@ def build_renderer(
         verbose=verbose,
     )
 
+    # 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
+
     return renderer, working_console
 
 

glaip_sdk/config/constants.py

@@ -6,10 +6,6 @@ Authors:
 
 # Default language model configuration
 DEFAULT_MODEL = "gpt-4.1"
-DEFAULT_MODEL_PROVIDER = "openai"
-
-# Default timeout values
-DEFAULT_TIMEOUT = 30.0
 DEFAULT_AGENT_RUN_TIMEOUT = 300
 
 # User agent and version

glaip_sdk/exceptions.py

@@ -98,9 +98,3 @@ class AgentTimeoutError(TimeoutError):
         super().__init__(message)
         self.timeout_seconds = timeout_seconds
         self.agent_name = agent_name
-
-
-class ClientError(APIError):
-    """Client-side error (e.g., invalid request format, missing parameters)."""
-
-    pass