glaip-sdk 0.6.5b3__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/cli/slash/accounts_controller.py

@@ -151,79 +151,149 @@ class AccountsController:
 
     def _render_textual(self, rows: list[dict[str, str | bool]], store: AccountStore, env_lock: bool) -> None:
         """Launch the Textual accounts browser."""
-        callbacks = AccountsTUICallbacks(switch_account=lambda name: self._switch_account(store, name, env_lock))
+        active_before = store.get_active_account()
+        notified = False
+
+        def _switch_in_textual(name: str) -> tuple[bool, str]:
+            nonlocal notified
+            switched, message = self._switch_account(
+                store,
+                name,
+                env_lock,
+                emit_console=False,
+                invalidate_session=True,
+            )
+            if switched:
+                notified = True
+            return switched, message
+
+        callbacks = AccountsTUICallbacks(switch_account=_switch_in_textual)
         active = next((row["name"] for row in rows if row.get("active")), None)
-        run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
-        # Exit snapshot: surface a success banner when a switch occurred inside the TUI
-        active_after = store.get_active_account() or "default"
+        try:
+            # Inject TUI context for theme support
+            tui_ctx = getattr(self.session, "tui_ctx", None)
+            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks, ctx=tui_ctx)
+        except Exception as exc:  # pragma: no cover - defensive around Textual failures
+            self.console.print(f"[{WARNING_STYLE}]Accounts browser exited unexpectedly: {exc}[/]")
+
+        # Exit snapshot: surface a success banner when a switch occurred inside the TUI.
+        # Always notify when the active account changed, even if Textual raised.
+        active_after = store.get_active_account()
+        if active_after != active_before and not notified:
+            self._notify_account_switched(active_after)
         if active_after != active:
             host_after = ""
-            account_after = store.get_account(active_after) if hasattr(store, "get_account") else None
+            display_account = active_after or "default"
+            account_after = store.get_account(display_account) if hasattr(store, "get_account") else None
             if account_after:
                 host_after = account_after.get("api_url", "")
             host_suffix = f" • {host_after}" if host_after else ""
             self.console.print(
                 AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {active_after}[/]{host_suffix}",
+                    f"[{SUCCESS_STYLE}]Active account ➜ {display_account}[/]{host_suffix}",
                     title="✅ Account Switched",
                     border_style=SUCCESS_STYLE,
                 )
             )
 
-    def _switch_account(self, store: AccountStore, name: str, env_lock: bool) -> tuple[bool, str]:
-        """Validate and switch active account; returns (success, message)."""
+    def _format_connection_error_message(self, error_reason: str, account_name: str, api_url: str) -> str:
+        """Format error message for connection validation failures."""
+        code, detail = self._parse_error_reason(error_reason)
+        if code == "connection_failed":
+            return f"Switch aborted: cannot reach {api_url}. Check URL or network."
+        if code == "api_failed":
+            return f"Switch aborted: API error for '{account_name}'. Check credentials."
+        detail_suffix = f": {detail}" if detail else ""
+        return f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
+
+    def _emit_error_message(self, msg: str, style: str = ERROR_STYLE) -> None:
+        """Emit an error or warning message to the console."""
+        self.console.print(f"[{style}]{msg}[/]")
+
+    def _validate_account_switch(
+        self, store: AccountStore, name: str, env_lock: bool, emit_console: bool
+    ) -> tuple[bool, str, dict[str, str] | None]:
+        """Validate account switch prerequisites; returns (is_valid, error_msg, account_dict)."""
         if env_lock:
             msg = "Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled."
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
         account = store.get_account(name)
         if not account:
             msg = f"Account '{name}' not found."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         api_url = account.get("api_url", "")
         api_key = account.get("api_key", "")
         if not api_url or not api_key:
             edit_cmd = f"aip accounts edit {name}"
             msg = f"Account '{name}' is missing credentials. Use `/login` or `{edit_cmd}`."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         ok, error_reason = check_connection_with_reason(api_url, api_key, abort_on_error=False)
         if not ok:
-            code, detail = self._parse_error_reason(error_reason)
-            if code == "connection_failed":
-                msg = f"Switch aborted: cannot reach {api_url}. Check URL or network."
-            elif code == "api_failed":
-                msg = f"Switch aborted: API error for '{name}'. Check credentials."
-            else:
-                detail_suffix = f": {detail}" if detail else ""
-                msg = f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            msg = self._format_connection_error_message(error_reason, name, api_url)
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
+        return True, "", account
+
+    def _execute_account_switch(
+        self, store: AccountStore, name: str, account: dict[str, str], invalidate_session: bool, emit_console: bool
+    ) -> tuple[bool, str]:
+        """Execute the account switch and emit success message."""
         try:
             store.set_active_account(name)
+            api_url = account.get("api_url", "")
+            api_key = account.get("api_key", "")
             masked_key = mask_api_key_display(api_key)
-            self.console.print(
-                AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
-                    title="✅ Account Switched",
-                    border_style=SUCCESS_STYLE,
+            if invalidate_session:
+                self._notify_account_switched(name)
+            if emit_console:
+                self.console.print(
+                    AIPPanel(
+                        f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
+                        title="✅ Account Switched",
+                        border_style=SUCCESS_STYLE,
+                    )
                 )
-            )
             return True, f"Switched to '{name}'."
         except AccountStoreError as exc:
             msg = f"Failed to set active account: {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
         except Exception as exc:  # NOSONAR(S1045) - catch-all needed for unexpected errors
             msg = f"Unexpected error while switching to '{name}': {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
 
+    def _switch_account(
+        self,
+        store: AccountStore,
+        name: str,
+        env_lock: bool,
+        *,
+        emit_console: bool = True,
+        invalidate_session: bool = True,
+    ) -> tuple[bool, str]:
+        """Validate and switch active account; returns (success, message)."""
+        is_valid, error_msg, account = self._validate_account_switch(store, name, env_lock, emit_console)
+        if not is_valid:
+            return False, error_msg
+
+        if account is None:  # Defensive – should never happen, but avoid crashing in production
+            return False, "Unable to locate account after validation."
+        return self._execute_account_switch(store, name, account, invalidate_session, emit_console)
+
     @staticmethod
     def _parse_error_reason(reason: str | None) -> tuple[str, str]:
         """Parse error reason into (code, detail) to avoid fragile substring checks."""
@@ -404,8 +474,18 @@ class AccountsController:
             except Exception as exc:
                 self.console.print(f"[{WARNING_STYLE}]Account saved but could not set active: {exc}[/]")
             else:
+                self._notify_account_switched(name)
                 self._announce_active_change(store, name)
 
+    def _notify_account_switched(self, name: str | None) -> None:
+        """Best-effort notify the hosting session that the active account changed."""
+        notify = getattr(self.session, "on_account_switched", None)
+        if callable(notify):
+            try:
+                notify(name)
+            except Exception:  # pragma: no cover - best-effort callback
+                pass
+
     def _confirm_delete_prompt(self, name: str) -> bool:
         """Ask for delete confirmation; return True when confirmed."""
         self.console.print(f"[{WARNING_STYLE}]Type '{name}' to confirm deletion. This cannot be undone.[/]")

glaip_sdk/cli/slash/agent_session.py

@@ -17,7 +17,7 @@ from glaip_sdk.cli.commands.agents import run as agents_run_command
 from glaip_sdk.cli.constants import DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT
 from glaip_sdk.cli.hints import format_command_hint
 from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT, FormattedText
-from glaip_sdk.cli.utils import bind_slash_session_context
+from glaip_sdk.cli.core.context import bind_slash_session_context
 
 if TYPE_CHECKING:  # pragma: no cover - type checking only
     from glaip_sdk.cli.slash.session import SlashSession
@@ -38,7 +38,10 @@ class AgentRunSession:
         self.console = session.console
         self._agent_id = str(getattr(agent, "id", ""))
         self._agent_name = getattr(agent, "name", "") or self._agent_id
-        self._prompt_placeholder: str = "Chat with this agent here; use / for shortcuts. Alt+Enter inserts a newline."
+        self._prompt_placeholder: str = (
+            "Chat with this agent here; use / for shortcuts. "
+            "Alt+Enter inserts a newline. Ctrl+T opens the last transcript."
+        )
         self._contextual_completion_help: dict[str, str] = {
             "details": "Show this agent's configuration (+ expands prompt).",
             "help": "Display this context-aware menu.",

glaip_sdk/cli/slash/prompt.py

@@ -162,6 +162,17 @@ def _create_key_bindings(_session: SlashSession) -> Any:
         if buffer.complete_state is not None:
             buffer.cancel_completion()
 
+    @bindings.add("c-t")  # type: ignore[misc]
+    def _handle_ctrl_t_key(event: Any) -> None:  # vulture: ignore
+        """Handle Ctrl+T key - open the transcript viewer (when available)."""
+        buffer = event.app.current_buffer
+        if buffer.complete_state is not None:
+            buffer.cancel_completion()
+
+        open_viewer = getattr(_session, "open_transcript_viewer", None)
+        if callable(open_viewer):
+            open_viewer(announce=True)
+
     return bindings
 
 

glaip_sdk/cli/slash/remote_runs_controller.py

@@ -30,7 +30,7 @@ from glaip_sdk.branding import (
 )
 from glaip_sdk.cli.constants import DEFAULT_REMOTE_RUNS_PAGE_LIMIT
 from glaip_sdk.cli.slash.tui.remote_runs_app import RemoteRunsTUICallbacks, run_remote_runs_textual
-from glaip_sdk.cli.utils import prompt_export_choice_questionary, questionary_safe_ask
+from glaip_sdk.cli.core.prompting import prompt_export_choice_questionary, questionary_safe_ask
 from glaip_sdk.exceptions import (
     AuthenticationError,
     ForbiddenError,
@@ -294,12 +294,14 @@ class RemoteRunsController:
             fetch_detail=fetch_detail,
             export_run=export_run,
         )
+        tui_ctx = getattr(self.session, "tui_ctx", None)
         page, limit, cursor = run_remote_runs_textual(
             runs_page,
             state.get("cursor", 0),
             callbacks,
             agent_name=agent_name,
             agent_id=agent_id,
+            ctx=tui_ctx,
         )
         state["page"] = page
         state["limit"] = limit