klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/ui/modes/repl/key_bindings.py

@@ -6,17 +6,26 @@ with dependencies injected to avoid circular imports.
 
 from __future__ import annotations
 
+import contextlib
 import re
 from collections.abc import Callable
 from typing import cast
 
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Always, Filter
+from prompt_toolkit.filters.app import has_completions
 from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 
 
 def create_key_bindings(
     capture_clipboard_tag: Callable[[], str | None],
     copy_to_clipboard: Callable[[str], None],
     at_token_pattern: re.Pattern[str],
+    *,
+    input_enabled: Filter | None = None,
+    open_model_picker: Callable[[], None] | None = None,
+    open_thinking_picker: Callable[[], None] | None = None,
 ) -> KeyBindings:
     """Create REPL key bindings with injected dependencies.
 
@@ -29,20 +38,96 @@ def create_key_bindings(
         KeyBindings instance with all REPL handlers configured
     """
     kb = KeyBindings()
+    enabled = input_enabled if input_enabled is not None else Always()
 
-    @kb.add("c-v")
-    def _(event):  # type: ignore
+    def _should_submit_instead_of_accepting_completion(buf: Buffer) -> bool:
+        """Return True when Enter should submit even if completions are visible.
+
+        We show completions proactively for contexts like `/`.
+        If the user already typed an exact candidate (e.g. `/clear`), accepting
+        a completion often only adds a trailing space and makes Enter require
+        two presses. In that case, prefer submitting.
+        """
+        state = buf.complete_state
+        if state is None or not state.completions:
+            return False
+
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            text = cast(str, doc.text)  # type: ignore[reportUnknownMemberType]
+            cursor_pos = cast(int, doc.cursor_position)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            return False
+
+        # Only apply this heuristic when the caret is at the end of the buffer.
+        if cursor_pos != len(text):
+            return False
+
+        for completion in state.completions:
+            try:
+                start = cursor_pos + completion.start_position
+                if start < 0 or start > cursor_pos:
+                    continue
+
+                replaced = text[start:cursor_pos]
+                inserted = completion.text
+
+                # If the user already typed an exact candidate, don't force
+                # accepting a completion (which often just adds a space).
+                if replaced == inserted or replaced == inserted.rstrip():
+                    return True
+            except Exception:
+                continue
+
+        return False
+
+    def _select_first_completion_if_needed(buf: Buffer) -> None:
+        """Ensure the completion menu has an active selection.
+
+        prompt_toolkit's default behavior keeps `complete_index=None` until the
+        user explicitly selects an item. We want the first item to be selected
+        by default, without modifying the buffer text.
+        """
+        state = buf.complete_state
+        if state is None or not state.completions:
+            return
+        if state.complete_index is None:
+            state.complete_index = 0
+
+    def _cycle_completion(buf: Buffer, *, delta: int) -> None:
+        state = buf.complete_state
+        if state is None or not state.completions:
+            return
+
+        _select_first_completion_if_needed(buf)
+        idx = state.complete_index or 0
+        state.complete_index = (idx + delta) % len(state.completions)
+
+    def _accept_current_completion(buf: Buffer) -> bool:
+        """Apply the currently selected completion, if any.
+
+        Returns True when a completion was applied.
+        """
+        state = buf.complete_state
+        if state is None or not state.completions:
+            return False
+
+        _select_first_completion_if_needed(buf)
+        completion = state.current_completion or state.completions[0]
+        buf.apply_completion(completion)
+        return True
+
+    @kb.add("c-v", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         """Paste image from clipboard as [Image #N]."""
         tag = capture_clipboard_tag()
         if tag:
-            try:
+            with contextlib.suppress(Exception):
                 event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
-            except Exception:
-                pass
 
-    @kb.add("enter")
-    def _(event):  # type: ignore
-        buf = event.current_buffer  # type: ignore
+    @kb.add("enter", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        buf = event.current_buffer
         doc = buf.document  # type: ignore
 
         # If VS Code/Windsurf/Cursor sent a "\\" sentinel before Enter (Shift+Enter mapping),
@@ -53,10 +138,16 @@ def create_key_bindings(
                 buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
                 buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
                 return
-        except Exception:
+        except (AttributeError, TypeError):
             # Fall through to default behavior if anything goes wrong
             pass
 
+        # When completions are visible, Enter accepts the current selection.
+        # This aligns with common TUI completion UX: navigation doesn't modify
+        # the buffer, and Enter/Tab inserts the selected option.
+        if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
+            return
+
         # If the entire buffer is whitespace-only, insert a newline rather than submitting.
         if len(buf.text.strip()) == 0:  # type: ignore
             buf.insert_text("\n")  # type: ignore
@@ -65,12 +156,30 @@ def create_key_bindings(
         # No need to persist manifest anymore - iter_inputs will handle image extraction
         buf.validate_and_handle()  # type: ignore
 
-    @kb.add("c-j")
-    def _(event):  # type: ignore
+    @kb.add("tab", filter=enabled & has_completions)
+    def _(event: KeyPressEvent) -> None:
+        buf = event.current_buffer
+        if _accept_current_completion(buf):
+            event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("down", filter=enabled & has_completions)
+    def _(event: KeyPressEvent) -> None:
+        buf = event.current_buffer
+        _cycle_completion(buf, delta=1)
+        event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("up", filter=enabled & has_completions)
+    def _(event: KeyPressEvent) -> None:
+        buf = event.current_buffer
+        _cycle_completion(buf, delta=-1)
+        event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("c-j", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         event.current_buffer.insert_text("\n")  # type: ignore
 
-    @kb.add("c")
-    def _(event):  # type: ignore
+    @kb.add("c", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         """Copy selected text to system clipboard, or insert 'c' if no selection."""
         buf = event.current_buffer  # type: ignore
         if buf.selection_state:  # type: ignore[reportUnknownMemberType]
@@ -84,8 +193,8 @@ def create_key_bindings(
         else:
             buf.insert_text("c")  # type: ignore[reportUnknownMemberType]
 
-    @kb.add("backspace")
-    def _(event):  # type: ignore
+    @kb.add("backspace", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         """Ensure completions refresh on backspace when editing an @token.
 
         We delete the character before cursor (default behavior), then explicitly
@@ -106,17 +215,17 @@ def create_key_bindings(
                 should_refresh = True
             elif buf.document.cursor_position_row == 0:  # type: ignore[reportUnknownMemberType]
                 # Check for slash command pattern without accessing protected attribute
-                text_before_str = cast(str, text_before or "")
+                text_before_str = text_before or ""
                 if text_before_str.strip().startswith("/") and " " not in text_before_str:
                     should_refresh = True
 
             if should_refresh:
                 buf.start_completion(select_first=False)  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, TypeError):
             pass
 
-    @kb.add("left")
-    def _(event):  # type: ignore
+    @kb.add("left", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         """Support wrapping to previous line when pressing left at column 0."""
         buf = event.current_buffer  # type: ignore
         try:
@@ -137,11 +246,11 @@ def create_key_bindings(
             # Default behavior: move one character left when possible.
             if doc.cursor_position > 0:  # type: ignore[reportUnknownMemberType]
                 buf.cursor_left()  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, IndexError, TypeError):
             pass
 
-    @kb.add("right")
-    def _(event):  # type: ignore
+    @kb.add("right", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
         """Support wrapping to next line when pressing right at line end."""
         buf = event.current_buffer  # type: ignore
         try:
@@ -164,7 +273,21 @@ def create_key_bindings(
             # Default behavior: move one character right when possible.
             if doc.cursor_position < len(doc.text):  # type: ignore[reportUnknownMemberType]
                 buf.cursor_right()  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, IndexError, TypeError):
             pass
 
+    @kb.add("c-l", filter=enabled, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        del event
+        if open_model_picker is not None:
+            with contextlib.suppress(Exception):
+                open_model_picker()
+
+    @kb.add("c-t", filter=enabled, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        del event
+        if open_thinking_picker is not None:
+            with contextlib.suppress(Exception):
+                open_thinking_picker()
+
     return kb

klaude_code/ui/modes/repl/renderer.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
+import contextlib
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Iterator
+from typing import Any
 
-from rich import box
-from rich.box import Box
-from rich.console import Console
+from rich.console import Console, Group, RenderableType
+from rich.padding import Padding
 from rich.spinner import Spinner
-from rich.status import Status
 from rich.style import Style, StyleType
 from rich.text import Text
 
+from klaude_code import const
 from klaude_code.protocol import events, model
 from klaude_code.ui.renderers import assistant as r_assistant
 from klaude_code.ui.renderers import developer as r_developer
@@ -21,16 +22,18 @@ from klaude_code.ui.renderers import sub_agent as r_sub_agent
 from klaude_code.ui.renderers import thinking as r_thinking
 from klaude_code.ui.renderers import tools as r_tools
 from klaude_code.ui.renderers import user_input as r_user_input
+from klaude_code.ui.renderers.common import truncate_display
 from klaude_code.ui.rich import status as r_status
+from klaude_code.ui.rich.live import CropAboveLive, SingleLine
 from klaude_code.ui.rich.quote import Quote
-from klaude_code.ui.rich.status import ShimmerStatusText
+from klaude_code.ui.rich.status import BreathingSpinner, ShimmerStatusText
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
-from klaude_code.ui.utils.common import truncate_display
 
 
 @dataclass
 class SessionStatus:
     color: Style | None = None
+    color_index: int | None = None
     sub_agent_state: model.SubAgentState | None = None
 
 
@@ -41,22 +44,32 @@ class REPLRenderer:
         self.themes = get_theme(theme)
         self.console: Console = Console(theme=self.themes.app_theme)
         self.console.push_theme(self.themes.markdown_theme)
-        self._spinner: Status = self.console.status(
-            ShimmerStatusText("Thinking …", ThemeKey.SPINNER_STATUS_TEXT),
-            spinner=r_status.spinner_name(),
-            spinner_style=ThemeKey.SPINNER_STATUS,
+        self._bottom_live: CropAboveLive | None = None
+        self._stream_renderable: RenderableType | None = None
+        self._stream_max_height: int = 0
+        self._stream_last_height: int = 0
+        self._stream_last_width: int = 0
+        self._spinner_visible: bool = False
+
+        self._status_text: ShimmerStatusText = ShimmerStatusText(const.STATUS_DEFAULT_TEXT)
+        self._status_spinner: Spinner = BreathingSpinner(
+            r_status.spinner_name(),
+            text=SingleLine(self._status_text),
+            style=ThemeKey.STATUS_SPINNER,
         )
 
         self.session_map: dict[str, SessionStatus] = {}
         self.current_sub_agent_color: Style | None = None
-        self.subagent_color_index = 0
+        self.sub_agent_color_index = 0
 
     def register_session(self, session_id: str, sub_agent_state: model.SubAgentState | None = None) -> None:
         session_status = SessionStatus(
             sub_agent_state=sub_agent_state,
         )
         if sub_agent_state is not None:
-            session_status.color = self.pick_sub_agent_color()
+            color, color_index = self.pick_sub_agent_color()
+            session_status.color = color
+            session_status.color_index = color_index
         self.session_map[session_id] = session_status
 
     def is_sub_agent_session(self, session_id: str) -> bool:
@@ -65,16 +78,16 @@ class REPLRenderer:
     def _advance_sub_agent_color_index(self) -> None:
         palette_size = len(self.themes.sub_agent_colors)
         if palette_size == 0:
-            self.subagent_color_index = 0
+            self.sub_agent_color_index = 0
             return
-        self.subagent_color_index = (self.subagent_color_index + 1) % palette_size
+        self.sub_agent_color_index = (self.sub_agent_color_index + 1) % palette_size
 
-    def pick_sub_agent_color(self) -> Style:
+    def pick_sub_agent_color(self) -> tuple[Style, int]:
         self._advance_sub_agent_color_index()
         palette = self.themes.sub_agent_colors
         if not palette:
-            return Style()
-        return palette[self.subagent_color_index]
+            return Style(), 0
+        return palette[self.sub_agent_color_index], self.sub_agent_color_index
 
     def get_session_sub_agent_color(self, session_id: str) -> Style:
         status = self.session_map.get(session_id)
@@ -82,8 +95,12 @@ class REPLRenderer:
             return status.color
         return Style()
 
-    def box_style(self) -> Box:
-        return box.ROUNDED
+    def get_session_sub_agent_background(self, session_id: str) -> Style:
+        status = self.session_map.get(session_id)
+        backgrounds = self.themes.sub_agent_backgrounds
+        if status and status.color_index is not None and backgrounds:
+            return backgrounds[status.color_index]
+        return Style()
 
     @contextmanager
     def session_print_context(self, session_id: str) -> Iterator[None]:
@@ -98,49 +115,22 @@ class REPLRenderer:
     def print(self, *objects: Any, style: StyleType | None = None, end: str = "\n") -> None:
         if self.current_sub_agent_color:
             if objects:
-                self.console.print(Quote(*objects, style=self.current_sub_agent_color))
+                content = objects[0] if len(objects) == 1 else objects
+                self.console.print(Quote(content, style=self.current_sub_agent_color), overflow="ellipsis")
             return
-        self.console.print(*objects, style=style, end=end)
+        self.console.print(*objects, style=style, end=end, overflow="ellipsis")
 
     def display_tool_call(self, e: events.ToolCallEvent) -> None:
-        # Handle sub-agent tool calls in replay mode
         if r_tools.is_sub_agent_tool(e.tool_name):
-            if e.is_replay:
-                state = r_sub_agent.build_sub_agent_state_from_tool_call(e)
-                if state is not None:
-                    sub_agent_default_style = (
-                        self.themes.sub_agent_colors[0] if self.themes.sub_agent_colors else Style()
-                    )
-                    self.print(
-                        Quote(
-                            r_sub_agent.render_sub_agent_call(state, sub_agent_default_style),
-                            style=sub_agent_default_style,
-                        )
-                    )
             return
-
         renderable = r_tools.render_tool_call(e)
         if renderable is not None:
             self.print(renderable)
 
     def display_tool_call_result(self, e: events.ToolResultEvent) -> None:
-        # Handle sub-agent tool results in replay mode
         if r_tools.is_sub_agent_tool(e.tool_name):
-            if e.is_replay:
-                sub_agent_default_style = self.themes.sub_agent_colors[0] if self.themes.sub_agent_colors else Style()
-                self.print(
-                    Quote(
-                        r_sub_agent.render_sub_agent_result(
-                            e.result,
-                            code_theme=self.themes.code_theme,
-                            style=sub_agent_default_style,
-                        ),
-                        style=sub_agent_default_style,
-                    )
-                )
             return
-
-        renderable = r_tools.render_tool_result(e)
+        renderable = r_tools.render_tool_result(e, code_theme=self.themes.code_theme)
         if renderable is not None:
             self.print(renderable)
 
@@ -159,37 +149,53 @@ class REPLRenderer:
     async def replay_history(self, history_events: events.ReplayHistoryEvent) -> None:
         tool_call_dict: dict[str, events.ToolCallEvent] = {}
         for event in history_events.events:
-            match event:
-                case events.TurnStartEvent():
-                    self.print()
-                case events.AssistantMessageEvent() as assistant_event:
-                    renderable = r_assistant.render_assistant_message(
-                        assistant_event.content, code_theme=self.themes.code_theme
-                    )
-                    if renderable is not None:
-                        self.print(renderable)
+            event_session_id = getattr(event, "session_id", history_events.session_id)
+            is_sub_agent = self.is_sub_agent_session(event_session_id)
+
+            with self.session_print_context(event_session_id):
+                match event:
+                    case events.TaskStartEvent() as e:
+                        self.display_task_start(e)
+                    case events.TurnStartEvent():
+                        self.print()
+                    case events.AssistantMessageEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        renderable = r_assistant.render_assistant_message(e.content, code_theme=self.themes.code_theme)
+                        if renderable is not None:
+                            self.print(renderable)
+                            self.print()
+                    case events.ThinkingEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        self.display_thinking(e.content)
+                    case events.DeveloperMessageEvent() as e:
+                        self.display_developer_message(e)
+                        self.display_command_output(e)
+                    case events.UserMessageEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        self.print(r_user_input.render_user_input(e.content))
+                    case events.ToolCallEvent() as e:
+                        tool_call_dict[e.tool_call_id] = e
+                    case events.ToolResultEvent() as e:
+                        tool_call_event = tool_call_dict.get(e.tool_call_id)
+                        if tool_call_event is not None:
+                            self.display_tool_call(tool_call_event)
+                        tool_call_dict.pop(e.tool_call_id, None)
+                        if is_sub_agent:
+                            continue
+                        self.display_tool_call_result(e)
+                    case events.TaskMetadataEvent() as e:
+                        self.print(r_metadata.render_task_metadata(e))
                         self.print()
-                case events.ThinkingEvent() as thinking_event:
-                    self.display_thinking(thinking_event.content)
-                case events.DeveloperMessageEvent() as developer_event:
-                    self.display_developer_message(developer_event)
-                    self.display_command_output(developer_event)
-                case events.UserMessageEvent() as user_event:
-                    self.print(r_user_input.render_user_input(user_event.content))
-                case events.ToolCallEvent() as tool_call_event:
-                    tool_call_dict[tool_call_event.tool_call_id] = tool_call_event
-                case events.ToolResultEvent() as tool_result_event:
-                    tool_call_event = tool_call_dict.get(tool_result_event.tool_call_id)
-                    if tool_call_event is not None:
-                        self.display_tool_call(tool_call_event)
-                    tool_call_dict.pop(tool_result_event.tool_call_id, None)
-                    self.display_tool_call_result(tool_result_event)
-                case events.ResponseMetadataEvent() as metadata_event:
-                    self.print(r_metadata.render_response_metadata(metadata_event))
-                    self.print()
-                case events.InterruptEvent():
-                    self.print()
-                    self.print(r_user_input.render_interrupt())
+                    case events.InterruptEvent():
+                        self.print()
+                        self.print(r_user_input.render_interrupt())
+                    case events.ErrorEvent() as e:
+                        self.display_error(e)
+                    case events.TaskFinishEvent() as e:
+                        self.display_task_finish(e)
 
     def display_developer_message(self, e: events.DeveloperMessageEvent) -> None:
         if not r_developer.need_render_developer_message(e):
@@ -205,7 +211,7 @@ class REPLRenderer:
             self.print()
 
     def display_welcome(self, event: events.WelcomeEvent) -> None:
-        self.print(r_metadata.render_welcome(event, box_style=self.box_style()))
+        self.print(r_metadata.render_welcome(event))
 
     def display_user_message(self, event: events.UserMessageEvent) -> None:
         self.print(r_user_input.render_user_input(event.content))
@@ -231,18 +237,28 @@ class REPLRenderer:
             self.print(renderable)
             self.print()
 
-    def display_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
+    def display_task_metadata(self, event: events.TaskMetadataEvent) -> None:
         with self.session_print_context(event.session_id):
-            self.print(r_metadata.render_response_metadata(event))
+            self.print(r_metadata.render_task_metadata(event))
             self.print()
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.is_sub_agent_session(event.session_id):
+            session_status = self.session_map.get(event.session_id)
+            description = (
+                session_status.sub_agent_state.sub_agent_desc
+                if session_status and session_status.sub_agent_state
+                else None
+            )
+            panel_style = self.get_session_sub_agent_background(event.session_id)
             with self.session_print_context(event.session_id):
                 self.print(
                     r_sub_agent.render_sub_agent_result(
                         event.task_result,
                         code_theme=self.themes.code_theme,
+                        has_structured_output=event.has_structured_output,
+                        description=description,
+                        panel_style=panel_style,
                     )
                 )
 
@@ -250,15 +266,11 @@ class REPLRenderer:
         self.print(r_user_input.render_interrupt())
 
     def display_error(self, event: events.ErrorEvent) -> None:
-        self.print(
-            r_errors.render_error(
-                self.console.render_str(truncate_display(event.error_message)),
-                indent=0,
-            )
-        )
-
-    def display_thinking_prefix(self) -> None:
-        self.print(r_thinking.thinking_prefix())
+        if event.session_id:
+            with self.session_print_context(event.session_id):
+                self.print(r_errors.render_error(truncate_display(event.error_message)))
+        else:
+            self.print(r_errors.render_error(truncate_display(event.error_message)))
 
     # -------------------------------------------------------------------------
     # Spinner control methods
@@ -266,16 +278,94 @@ class REPLRenderer:
 
     def spinner_start(self) -> None:
         """Start the spinner animation."""
-        self._spinner.start()
+        self._spinner_visible = True
+        self._ensure_bottom_live_started()
+        self._refresh_bottom_live()
 
     def spinner_stop(self) -> None:
         """Stop the spinner animation."""
-        self._spinner.stop()
+        self._spinner_visible = False
+        self._refresh_bottom_live()
 
-    def spinner_update(self, status_text: str | Text) -> None:
-        """Update the spinner status text."""
-        self._spinner.update(ShimmerStatusText(status_text, ThemeKey.SPINNER_STATUS_TEXT))
+    def spinner_update(self, status_text: str | Text, right_text: RenderableType | None = None) -> None:
+        """Update the spinner status text with optional right-aligned text."""
+        self._status_text = ShimmerStatusText(status_text, right_text)
+        self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)
+        self._refresh_bottom_live()
 
     def spinner_renderable(self) -> Spinner:
         """Return the spinner's renderable for embedding in other components."""
-        return self._spinner.renderable
+        return self._status_spinner
+
+    def set_stream_renderable(self, renderable: RenderableType | None) -> None:
+        """Set the current streaming renderable displayed above the status line."""
+
+        if renderable is None:
+            self._stream_renderable = None
+            self._stream_max_height = 0
+            self._stream_last_height = 0
+            self._stream_last_width = 0
+            self._refresh_bottom_live()
+            return
+
+        self._ensure_bottom_live_started()
+        self._stream_renderable = renderable
+
+        height = len(self.console.render_lines(renderable, self.console.options, pad=False))
+        self._stream_last_height = height
+        self._stream_last_width = self.console.size.width
+        self._stream_max_height = max(self._stream_max_height, height)
+        self._refresh_bottom_live()
+
+    def _ensure_bottom_live_started(self) -> None:
+        if self._bottom_live is not None:
+            return
+        self._bottom_live = CropAboveLive(
+            Text(""),
+            console=self.console,
+            refresh_per_second=30,
+            transient=True,
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        self._bottom_live.start()
+
+    def _bottom_renderable(self) -> RenderableType:
+        stream_part: RenderableType = Group()
+        gap_part: RenderableType = Group()
+
+        if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED:
+            stream = self._stream_renderable
+            if stream is not None:
+                current_width = self.console.size.width
+                if self._stream_last_width != current_width:
+                    height = len(self.console.render_lines(stream, self.console.options, pad=False))
+                    self._stream_last_height = height
+                    self._stream_last_width = current_width
+                    self._stream_max_height = max(self._stream_max_height, height)
+                else:
+                    height = self._stream_last_height
+
+                pad_lines = max(self._stream_max_height - height, 0)
+                if pad_lines:
+                    stream = Padding(stream, (0, 0, pad_lines, 0))
+                stream_part = stream
+
+            gap_part = Text("") if self._spinner_visible else Group()
+
+        status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
+        return Group(stream_part, gap_part, status_part)
+
+    def _refresh_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        self._bottom_live.update(self._bottom_renderable(), refresh=True)
+
+    def stop_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        with contextlib.suppress(Exception):
+            # Avoid cursor restore when stopping right before prompt_toolkit.
+            self._bottom_live.transient = False
+            self._bottom_live.stop()
+        self._bottom_live = None