glaip-sdk 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

glaip_sdk/cli/config.py

@@ -12,7 +12,12 @@ import yaml
 
 CONFIG_DIR = Path.home() / ".aip"
 CONFIG_FILE = CONFIG_DIR / "config.yaml"
-_ALLOWED_KEYS = {"api_url", "api_key", "timeout"}
+_ALLOWED_KEYS = {
+    "api_url",
+    "api_key",
+    "timeout",
+    "history_default_limit",
+}
 
 
 def _sanitize_config(data: dict[str, Any] | None) -> dict[str, Any]:

glaip_sdk/cli/display.py

@@ -208,6 +208,7 @@ def build_resource_result_data(resource: Any, fields: list[str]) -> dict[str, An
 
 
 def _normalise_field_value(field: str, value: Any) -> Any:
+    """Convert special sentinel values into display-friendly text."""
     if value is _MISSING:
         return "N/A"
     if hasattr(value, "_mock_name"):

glaip_sdk/cli/main.py

@@ -13,7 +13,6 @@ import click
 from rich.console import Console
 
 from glaip_sdk import Client
-from glaip_sdk._version import __version__ as _SDK_VERSION
 from glaip_sdk.branding import (
     ERROR,
     ERROR_STYLE,
@@ -34,11 +33,12 @@ from glaip_sdk.cli.commands.configure import (
 from glaip_sdk.cli.commands.mcps import mcps_group
 from glaip_sdk.cli.commands.models import models_group
 from glaip_sdk.cli.commands.tools import tools_group
+from glaip_sdk.cli.commands.transcripts import transcripts_group
 from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.config import load_config
 from glaip_sdk.cli.transcript import get_transcript_cache_stats
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import in_slash_mode, spinner_context, update_spinner
+from glaip_sdk.cli.utils import format_size, in_slash_mode, sdk_version, spinner_context, update_spinner
 from glaip_sdk.config.constants import (
     DEFAULT_AGENT_RUN_TIMEOUT,
 )
@@ -56,26 +56,8 @@ except ImportError:  # pragma: no cover - optional slash dependencies
 AVAILABLE_STATUS = "✅ Available"
 
 
-def _format_size(num: int) -> str:
-    """Return a human-readable byte size."""
-    if num <= 0:
-        return "0B"
-
-    units = ["B", "KB", "MB", "GB", "TB"]
-    value = float(num)
-    for unit in units:
-        if value < 1024 or unit == units[-1]:
-            if value >= 100 or unit == "B":
-                return f"{value:.0f}{unit}"
-            if value >= 10:
-                return f"{value:.1f}{unit}"
-            return f"{value:.2f}{unit}"
-        value /= 1024
-    return f"{value:.1f}TB"  # pragma: no cover - defensive fallback
-
-
 @click.group(invoke_without_command=True)
-@click.version_option(version=_SDK_VERSION, prog_name="aip")
+@click.version_option(package_name="glaip-sdk", prog_name="aip")
 @click.option(
     "--api-url",
     envvar="AIP_API_URL",
@@ -136,7 +118,7 @@ def main(
     if not ctx.resilient_parsing and ctx.obj["tty"] and not launching_slash:
         console = Console()
         maybe_notify_update(
-            _SDK_VERSION,
+            sdk_version(),
             console=console,
             ctx=ctx,
             slash_command="update",
@@ -158,6 +140,7 @@ main.add_command(config_group)
 main.add_command(tools_group)
 main.add_command(mcps_group)
 main.add_command(models_group)
+main.add_command(transcripts_group)
 
 # Add top-level commands
 main.add_command(configure_command)
@@ -215,7 +198,7 @@ def _validate_config_and_show_error(config: dict, console: Console) -> None:
                 border_style=ERROR,
             )
         )
-        console.print(f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{_SDK_VERSION}) - Configure to connect")
+        console.print(f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{sdk_version()}) - Configure to connect")
         sys.exit(1)
 
 
@@ -233,7 +216,7 @@ def _render_status_heading(console: Console, slash_mode: bool) -> None:
     del slash_mode  # heading now consistent across invocation contexts
     console.print(f"[{INFO_STYLE}]GL AIP status[/]")
     console.print()
-    console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{_SDK_VERSION})")
+    console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{sdk_version()})")
 
 
 def _collect_cache_summary() -> tuple[str | None, str | None]:
@@ -241,15 +224,15 @@ def _collect_cache_summary() -> tuple[str | None, str | None]:
     try:
         cache_stats = get_transcript_cache_stats()
     except Exception:
-        return "[dim]Saved run history[/dim]: unavailable", None
+        return "[dim]Saved transcripts[/dim]: unavailable", None
 
     runs_text = f"{cache_stats.entry_count} runs saved"
     if cache_stats.total_bytes:
-        size_part = f" · {_format_size(cache_stats.total_bytes)} used"
+        size_part = f" · {format_size(cache_stats.total_bytes)} used"
     else:
         size_part = ""
 
-    cache_line = f"[dim]Saved run history[/dim]: {runs_text}{size_part} · {cache_stats.cache_dir}"
+    cache_line = f"[dim]Saved transcripts[/dim]: {runs_text}{size_part} · {cache_stats.cache_dir}"
     return cache_line, None
 
 
@@ -391,7 +374,7 @@ def status(ctx: Any) -> None:
 @main.command()
 def version() -> None:
     """Show version information."""
-    branding = AIPBranding.create_from_sdk(sdk_version=_SDK_VERSION, package_name="glaip-sdk")
+    branding = AIPBranding.create_from_sdk(sdk_version=sdk_version(), package_name="glaip-sdk")
     branding.display_version_panel()
 
 
@@ -430,14 +413,11 @@ def update(check_only: bool, force: bool) -> None:
 
         # Update using pip
         try:
-            cmd = [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                "glaip-sdk",
-            ]
+            from glaip_sdk.cli.commands.update import _build_upgrade_command
+
+            cmd = list(_build_upgrade_command(include_prerelease=False))
+            # Replace package name with "glaip-sdk" (main.py uses different name)
+            cmd[-1] = "glaip-sdk"
             if force:
                 cmd.insert(5, "--force-reinstall")
             subprocess.run(cmd, capture_output=True, text=True, check=True)
@@ -492,4 +472,4 @@ def update(check_only: bool, force: bool) -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()  # pylint: disable=no-value-for-parameter

glaip_sdk/cli/parsers/__init__.py

@@ -4,6 +4,4 @@ Authors:
     Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
 """
 
-from glaip_sdk.cli.parsers.json_input import parse_json_input
-
-__all__ = ["parse_json_input"]
+__all__: list[str] = []

glaip_sdk/cli/slash/__init__.py

@@ -6,19 +6,10 @@ Authors:
 
 from glaip_sdk.cli.commands.agents import get as agents_get_command
 from glaip_sdk.cli.commands.agents import run as agents_run_command
-from glaip_sdk.cli.commands.configure import configure_command, load_config
-from glaip_sdk.cli.slash.agent_session import AgentRunSession
-from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT
 from glaip_sdk.cli.slash.session import SlashSession
-from glaip_sdk.cli.utils import get_client
 
 __all__ = [
-    "AgentRunSession",
     "SlashSession",
-    "_HAS_PROMPT_TOOLKIT",
     "agents_get_command",
     "agents_run_command",
-    "configure_command",
-    "get_client",
-    "load_config",
 ]

glaip_sdk/cli/slash/prompt.py

@@ -163,6 +163,7 @@ def _create_key_bindings(_session: SlashSession) -> Any:
 def _iter_command_completions(
     session: SlashSession, text: str
 ) -> Iterable[Completion]:  # pragma: no cover - thin wrapper
+    """Yield completions for global slash commands."""
     prefix = text[1:]
     seen: set[str] = set()
 
@@ -203,6 +204,7 @@ def _generate_command_completions(cmd: Any, prefix: str, text: str, seen: set[st
 def _iter_contextual_completions(
     session: SlashSession, text: str
 ) -> Iterable[Completion]:  # pragma: no cover - thin wrapper
+    """Yield completions for context-specific slash commands."""
     prefix = text[1:]
     seen: set[str] = set()
 

glaip_sdk/cli/slash/session.py

@@ -33,6 +33,7 @@ from glaip_sdk.branding import (
     WARNING_STYLE,
     AIPBranding,
 )
+from glaip_sdk.cli.commands import transcripts as transcripts_cmd
 from glaip_sdk.cli.commands.configure import configure_command, load_config
 from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.slash.agent_session import AgentRunSession
@@ -46,9 +47,7 @@ from glaip_sdk.cli.slash.prompt import (
 )
 from glaip_sdk.cli.transcript import (
     export_cached_transcript,
-    normalise_export_destination,
-    resolve_manifest_for_export,
-    suggest_filename,
+    load_history_snapshot,
 )
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 from glaip_sdk.cli.update_notifier import maybe_notify_update
@@ -56,6 +55,7 @@ from glaip_sdk.cli.utils import (
     _fuzzy_pick_for_resources,
     command_hint,
     format_command_hint,
+    format_size,
     get_client,
 )
 from glaip_sdk.rich_components import AIPGrid, AIPPanel, AIPTable
@@ -73,6 +73,39 @@ class SlashCommand:
     aliases: tuple[str, ...] = ()
 
 
+NEW_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
+    {
+        "cli": "transcripts",
+        "slash": "transcripts",
+        "description": "Review transcript cache",
+        "tag": "NEW",
+        "priority": 10,
+    },
+)
+
+
+DEFAULT_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
+    {
+        "cli": "status",
+        "slash": "status",
+        "description": "Connection check",
+        "priority": 0,
+    },
+    {
+        "cli": "agents list",
+        "slash": "agents",
+        "description": "Browse agents",
+        "priority": 0,
+    },
+    {
+        "cli": "help",
+        "slash": "help",
+        "description": "Show all commands",
+        "priority": 0,
+    },
+)
+
+
 class SlashSession:
     """Interactive command palette controller."""
 
@@ -99,7 +132,7 @@ class SlashSession:
         self._active_renderer: Any | None = None
         self._current_agent: Any | None = None
 
-        self._home_placeholder = "Start with / to browse commands"
+        self._home_placeholder = "Hint: type / to explore commands · Ctrl+D exits"
 
         # Command string constants to avoid duplication
         self.STATUS_COMMAND = "/status"
@@ -263,6 +296,10 @@ class SlashSession:
             return False
         return True
 
+    def _continue_session(self) -> bool:
+        """Signal that the slash session should remain active."""
+        return not self._should_exit
+
     # ------------------------------------------------------------------
     # Command handlers
     # ------------------------------------------------------------------
@@ -345,7 +382,7 @@ class SlashSession:
                 self._show_default_quick_actions()
         except click.ClickException as exc:
             self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
-        return True
+        return self._continue_session()
 
     def _cmd_status(self, _args: list[str], _invoked_from_agent: bool) -> bool:
         ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
@@ -374,7 +411,116 @@ class SlashSession:
                     ctx_obj.pop("_slash_console", None)
                 else:
                     ctx_obj["_slash_console"] = previous_console
-        return True
+        return self._continue_session()
+
+    def _cmd_transcripts(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        if args and args[0].lower() in {"detail", "show"}:
+            if len(args) < 2:
+                self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts detail <run_id>[/]")
+                return self._continue_session()
+            self._show_transcript_detail(args[1])
+            return self._continue_session()
+
+        limit, ok = self._parse_transcripts_limit(args)
+        if not ok:
+            return self._continue_session()
+
+        snapshot = load_history_snapshot(limit=limit, ctx=self.ctx)
+
+        if self._handle_transcripts_empty(snapshot, limit):
+            return self._continue_session()
+
+        self._render_transcripts_snapshot(snapshot)
+        return self._continue_session()
+
+    def _parse_transcripts_limit(self, args: list[str]) -> tuple[int | None, bool]:
+        if not args:
+            return None, True
+        try:
+            limit = int(args[0])
+        except ValueError:
+            self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts [limit][/]")
+            return None, False
+        if limit < 0:
+            self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts [limit][/]")
+            return None, False
+        return limit, True
+
+    def _handle_transcripts_empty(self, snapshot: Any, limit: int | None) -> bool:
+        if snapshot.cached_entries == 0:
+            self.console.print(f"[{WARNING_STYLE}]No cached transcripts yet. Run an agent first.[/]")
+            for warning in snapshot.warnings:
+                self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+            return True
+        if limit == 0 and snapshot.cached_entries:
+            self.console.print(f"[{WARNING_STYLE}]Limit is 0; nothing to display.[/]")
+            return True
+        return False
+
+    def _render_transcripts_snapshot(self, snapshot: Any) -> None:
+        size_text = format_size(snapshot.total_size_bytes)
+        header = f"[dim]Manifest: {snapshot.manifest_path} · {snapshot.total_entries} runs · {size_text} used[/]"
+        self.console.print(header)
+
+        if snapshot.limit_clamped:
+            self.console.print(
+                f"[{WARNING_STYLE}]Requested limit exceeded maximum; showing first {snapshot.limit_applied} runs.[/]"
+            )
+
+        if snapshot.total_entries > len(snapshot.entries):
+            subset_message = (
+                f"[dim]Showing {len(snapshot.entries)} of {snapshot.total_entries} "
+                f"runs (limit={snapshot.limit_applied}).[/]"
+            )
+            self.console.print(subset_message)
+            self.console.print("[dim]Hint: run `/transcripts <limit>` to change how many rows are displayed.[/]")
+
+        if snapshot.migration_summary:
+            self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+
+        for warning in snapshot.warnings:
+            self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+
+        table = transcripts_cmd._build_table(snapshot.entries)
+        self.console.print(table)
+        self.console.print("[dim]! Missing transcript[/]")
+
+    def _show_transcript_detail(self, run_id: str) -> None:
+        """Render the cached transcript log for a single run."""
+        snapshot = load_history_snapshot(ctx=self.ctx)
+        entry = snapshot.index.get(run_id)
+        if entry is None:
+            self.console.print(f"[{WARNING_STYLE}]Run id {run_id} was not found in the cache manifest.[/]")
+            return
+
+        try:
+            transcript_path, transcript_text = transcripts_cmd._load_transcript_text(entry)
+        except click.ClickException as exc:
+            self.console.print(f"[{WARNING_STYLE}]{exc}[/]")
+            return
+
+        meta, events = transcripts_cmd._decode_transcript(transcript_text)
+        if transcripts_cmd._maybe_launch_transcript_viewer(
+            self.ctx,
+            entry,
+            meta,
+            events,
+            console_override=self.console,
+            force=True,
+            initial_view="transcript",
+        ):
+            if snapshot.migration_summary:
+                self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+            for warning in snapshot.warnings:
+                self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+            return
+
+        if snapshot.migration_summary:
+            self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+        for warning in snapshot.warnings:
+            self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+        view = transcripts_cmd._render_transcript_display(entry, snapshot.manifest_path, transcript_path, meta, events)
+        self.console.print(view, markup=False, highlight=False, soft_wrap=True, end="")
 
     def _cmd_agents(self, args: list[str], _invoked_from_agent: bool) -> bool:
         client = self._get_client_or_fail()
@@ -442,7 +588,7 @@ class SlashSession:
         self._render_header()
 
         self._show_agent_followup_actions(picked_agent)
-        return True
+        return self._continue_session()
 
     def _show_agent_followup_actions(self, picked_agent: Any) -> None:
         """Show follow-up action hints after agent session."""
@@ -498,6 +644,13 @@ class SlashSession:
                 handler=SlashSession._cmd_status,
             )
         )
+        self._register(
+            SlashCommand(
+                name="transcripts",
+                help="Review cached transcript history. Add a number (e.g. `/transcripts 5`) to change the row limit.",
+                handler=SlashSession._cmd_transcripts,
+            )
+        )
         self._register(
             SlashCommand(
                 name="agents",
@@ -574,55 +727,13 @@ class SlashSession:
         manifest = ctx_obj.get("_last_transcript_manifest")
         return payload, manifest
 
-    def _cmd_export(self, args: list[str], _invoked_from_agent: bool) -> bool:
+    def _cmd_export(self, _args: list[str], _invoked_from_agent: bool) -> bool:
         """Slash handler for `/export` command."""
-        path_arg = args[0] if args else None
-        run_id = args[1] if len(args) > 1 else None
-
-        manifest_entry = resolve_manifest_for_export(self.ctx, run_id)
-        if manifest_entry is None:
-            if run_id:
-                self.console.print(
-                    f"[{WARNING_STYLE}]No cached transcript found with run id {run_id!r}. "
-                    "Omit the run id to export the most recent run.[/]"
-                )
-            else:
-                self.console.print(f"[{WARNING_STYLE}]No cached transcripts available yet. Run an agent first.[/]")
-            return False
-
-        destination = self._resolve_export_destination(path_arg, manifest_entry)
-        if destination is None:
-            return False
-
-        try:
-            exported = export_cached_transcript(
-                destination=destination,
-                run_id=manifest_entry.get("run_id"),
-            )
-        except FileNotFoundError as exc:
-            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
-            return False
-        except Exception as exc:  # pragma: no cover - unexpected IO failures
-            self.console.print(f"[{ERROR_STYLE}]Failed to export transcript: {exc}[/]")
-            return False
-        else:
-            self.console.print(f"[{SUCCESS_STYLE}]Transcript exported to[/] {exported}")
-            return True
-
-    def _resolve_export_destination(self, path_arg: str | None, manifest_entry: dict[str, Any]) -> Path | None:
-        if path_arg:
-            return normalise_export_destination(Path(path_arg))
-
-        default_name = suggest_filename(manifest_entry)
-        prompt = f"Save transcript to [{default_name}]: "
-        try:
-            response = self.console.input(prompt)
-        except EOFError:
-            self.console.print("[dim]Export cancelled.[/dim]")
-            return None
-
-        chosen = response.strip() or default_name
-        return normalise_export_destination(Path(chosen))
+        self.console.print(
+            f"[{WARNING_STYLE}]`/export` is deprecated. Use `/transcripts`, select a run, "
+            "and open the transcript viewer to export.[/]"
+        )
+        return True
 
     def _cmd_update(self, args: list[str], _invoked_from_agent: bool) -> bool:
         """Slash handler for `/update` command."""
@@ -981,35 +1092,73 @@ class SlashSession:
         return None
 
     def _show_default_quick_actions(self) -> None:
-        hints: list[tuple[str | None, str]] = [
-            (
-                command_hint("status", slash_command="status", ctx=self.ctx),
-                "Connection check",
-            ),
-            (
-                command_hint("agents list", slash_command="agents", ctx=self.ctx),
-                "Browse agents",
-            ),
-            (
-                command_hint("help", slash_command="help", ctx=self.ctx),
-                "Show all commands",
-            ),
-        ]
-        filtered = [(cmd, desc) for cmd, desc in hints if cmd]
-        if filtered:
-            self._show_quick_actions(filtered, title="Quick actions")
+        new_hints = self._collect_quick_action_hints(NEW_QUICK_ACTIONS, highlight_new=True)
+        evergreen_hints = self._collect_quick_action_hints(DEFAULT_QUICK_ACTIONS)
+        if new_hints or evergreen_hints:
+            self.console.print(f"[dim]{'─' * 40}[/]")
+        self._render_quick_action_group(new_hints, "New commands")
+        self._render_quick_action_group(evergreen_hints, "Quick actions")
         self._default_actions_shown = True
 
+    def _collect_quick_action_hints(
+        self,
+        actions: Iterable[dict[str, Any]],
+        *,
+        highlight_new: bool = False,
+    ) -> list[tuple[str, str]]:
+        collected: list[tuple[str, str]] = []
+        for action in sorted(actions, key=lambda payload: payload.get("priority", 0), reverse=True):
+            hint = self._build_quick_action_hint(action, highlight_new=highlight_new)
+            if hint:
+                collected.append(hint)
+        return collected
+
+    def _build_quick_action_hint(
+        self,
+        action: dict[str, Any],
+        *,
+        highlight_new: bool = False,
+    ) -> tuple[str, str] | None:
+        command = command_hint(action.get("cli"), slash_command=action.get("slash"), ctx=self.ctx)
+        if not command:
+            return None
+        description = action.get("description", "")
+        tag = action.get("tag")
+        if tag:
+            description = f"[{ACCENT_STYLE}]{tag}[/] · {description}"
+        if highlight_new:
+            description = f"✨ {description}"
+        return command, description
+
+    def _render_quick_action_group(self, hints: list[tuple[str, str]], title: str) -> None:
+        if not hints:
+            return
+        formatted_tokens: list[str] = []
+        for command, description in hints:
+            formatted = format_command_hint(command, description)
+            if formatted:
+                formatted_tokens.append(f"• {formatted}")
+        if not formatted_tokens:
+            return
+        header = f"[dim]{title}[/dim] · {formatted_tokens[0]}"
+        self.console.print(header)
+        remaining = formatted_tokens[1:]
+        for chunk in self._chunk_tokens(remaining, size=3):
+            self.console.print("  " + "    ".join(chunk))
+
+    def _chunk_tokens(self, tokens: list[str], *, size: int) -> Iterable[list[str]]:
+        for index in range(0, len(tokens), size):
+            yield tokens[index : index + size]
+
     def _render_home_hint(self) -> None:
         if self._home_hint_shown:
             return
-        hint_lines = [
-            f"[{HINT_PREFIX_STYLE}]Hint:[/]",
-            f"  Type {format_command_hint('/') or '/'} to explore commands",
-            "  Press [dim]Ctrl+C[/] to cancel the current entry",
-            "  Press [dim]Ctrl+D[/] to quit",
-        ]
-        self.console.print("\n".join(hint_lines))
+        hint_text = (
+            f"[{HINT_PREFIX_STYLE}]Hint:[/] "
+            f"Type {format_command_hint('/') or '/'} to explore commands · "
+            "Press [dim]Ctrl+D[/] to quit"
+        )
+        self.console.print(hint_text)
         self._home_hint_shown = True
 
     def _show_quick_actions(
@@ -1019,26 +1168,40 @@ class SlashSession:
         title: str = "Quick actions",
         inline: bool = False,
     ) -> None:
-        hint_list = [(command, description) for command, description in hints if command]
+        hint_list = self._normalize_quick_action_hints(hints)
         if not hint_list:
             return
 
         if inline:
-            lines: list[str] = []
-            for command, description in hint_list:
-                formatted = format_command_hint(command, description)
-                if formatted:
-                    lines.append(formatted)
-            if lines:
-                self.console.print("\n".join(lines))
+            self._render_inline_quick_actions(hint_list, title)
             return
 
+        self._render_panel_quick_actions(hint_list, title)
+
+    def _normalize_quick_action_hints(self, hints: Iterable[tuple[str, str]]) -> list[tuple[str, str]]:
+        return [(command, description) for command, description in hints if command]
+
+    def _render_inline_quick_actions(self, hint_list: list[tuple[str, str]], title: str) -> None:
+        tokens: list[str] = []
+        for command, description in hint_list:
+            formatted = format_command_hint(command, description)
+            if formatted:
+                tokens.append(formatted)
+        if not tokens:
+            return
+        prefix = f"[dim]{title}:[/]" if title else ""
+        body = "    ".join(tokens)
+        text = f"{prefix} {body}" if prefix else body
+        self.console.print(text.strip())
+
+    def _render_panel_quick_actions(self, hint_list: list[tuple[str, str]], title: str) -> None:
         body_lines: list[Text] = []
         for command, description in hint_list:
             formatted = format_command_hint(command, description)
             if formatted:
                 body_lines.append(Text.from_markup(formatted))
-
+        if not body_lines:
+            return
         panel_content = Group(*body_lines)
         self.console.print(AIPPanel(panel_content, title=title, border_style=SECONDARY_LIGHT, expand=False))