klaude-code 1.2.6__py3-none-any.whl

klaude_code/ui/modes/repl/key_bindings.py

@@ -0,0 +1,170 @@
+"""REPL keyboard bindings for prompt_toolkit.
+
+This module provides the factory function to create key bindings for the REPL input,
+with dependencies injected to avoid circular imports.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import cast
+
+from prompt_toolkit.key_binding import KeyBindings
+
+
+def create_key_bindings(
+    capture_clipboard_tag: Callable[[], str | None],
+    copy_to_clipboard: Callable[[str], None],
+    at_token_pattern: re.Pattern[str],
+) -> KeyBindings:
+    """Create REPL key bindings with injected dependencies.
+
+    Args:
+        capture_clipboard_tag: Callable to capture clipboard image and return tag
+        copy_to_clipboard: Callable to copy text to system clipboard
+        at_token_pattern: Pattern to match @token for completion refresh
+
+    Returns:
+        KeyBindings instance with all REPL handlers configured
+    """
+    kb = KeyBindings()
+
+    @kb.add("c-v")
+    def _(event):  # type: ignore
+        """Paste image from clipboard as [Image #N]."""
+        tag = capture_clipboard_tag()
+        if tag:
+            try:
+                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
+        doc = buf.document  # type: ignore
+
+        # If VS Code/Windsurf/Cursor sent a "\\" sentinel before Enter (Shift+Enter mapping),
+        # treat it as a request for a newline instead of submit.
+        # This allows Shift+Enter to insert a newline in our multiline prompt.
+        try:
+            if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
+                buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
+                return
+        except Exception:
+            # Fall through to default behavior if anything goes wrong
+            pass
+
+        # 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
+            return
+
+        # 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
+        event.current_buffer.insert_text("\n")  # type: ignore
+
+    @kb.add("c")
+    def _(event):  # type: ignore
+        """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]
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            start, end = doc.selection_range()  # type: ignore[reportUnknownMemberType]
+            selected_text: str = doc.text[start:end]  # type: ignore[reportUnknownMemberType]
+
+            if selected_text:
+                copy_to_clipboard(selected_text)  # type: ignore[reportUnknownArgumentType]
+            buf.exit_selection()  # type: ignore[reportUnknownMemberType]
+        else:
+            buf.insert_text("c")  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("backspace")
+    def _(event):  # type: ignore
+        """Ensure completions refresh on backspace when editing an @token.
+
+        We delete the character before cursor (default behavior), then explicitly
+        trigger completion refresh if the caret is still within an @... token.
+        """
+        buf = event.current_buffer  # type: ignore
+        # Handle selection: cut selection if present, otherwise delete one character
+        if buf.selection_state:  # type: ignore[reportUnknownMemberType]
+            buf.cut_selection()  # type: ignore[reportUnknownMemberType]
+        else:
+            buf.delete_before_cursor()  # type: ignore[reportUnknownMemberType]
+        # If the token pattern still applies, refresh completion popup
+        try:
+            text_before = buf.document.text_before_cursor  # type: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            # Check for both @ tokens and / tokens (slash commands on first line only)
+            should_refresh = False
+            if at_token_pattern.search(text_before):  # type: ignore[reportUnknownArgumentType]
+                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 "")
+                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:
+            pass
+
+    @kb.add("left")
+    def _(event):  # type: ignore
+        """Support wrapping to previous line when pressing left at column 0."""
+        buf = event.current_buffer  # type: ignore
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            row = cast(int, doc.cursor_position_row)  # type: ignore[reportUnknownMemberType]
+            col = cast(int, doc.cursor_position_col)  # type: ignore[reportUnknownMemberType]
+
+            # At the beginning of a non-first line: jump to previous line end.
+            if col == 0 and row > 0:
+                lines = cast(list[str], doc.lines)  # type: ignore[reportUnknownMemberType]
+                prev_row = row - 1
+                if 0 <= prev_row < len(lines):
+                    prev_line = lines[prev_row]
+                    new_index = doc.translate_row_col_to_index(prev_row, len(prev_line))  # type: ignore[reportUnknownMemberType]
+                    buf.cursor_position = new_index  # type: ignore[reportUnknownMemberType]
+                return
+
+            # Default behavior: move one character left when possible.
+            if doc.cursor_position > 0:  # type: ignore[reportUnknownMemberType]
+                buf.cursor_left()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+    @kb.add("right")
+    def _(event):  # type: ignore
+        """Support wrapping to next line when pressing right at line end."""
+        buf = event.current_buffer  # type: ignore
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            row = cast(int, doc.cursor_position_row)  # type: ignore[reportUnknownMemberType]
+            col = cast(int, doc.cursor_position_col)  # type: ignore[reportUnknownMemberType]
+            lines = cast(list[str], doc.lines)  # type: ignore[reportUnknownMemberType]
+
+            current_line = lines[row] if 0 <= row < len(lines) else ""
+            at_line_end = col >= len(current_line)
+            is_last_line = row >= len(lines) - 1 if lines else True
+
+            # At end of a non-last line: jump to next line start.
+            if at_line_end and not is_last_line:
+                next_row = row + 1
+                new_index = doc.translate_row_col_to_index(next_row, 0)  # type: ignore[reportUnknownMemberType]
+                buf.cursor_position = new_index  # type: ignore[reportUnknownMemberType]
+                return
+
+            # 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:
+            pass
+
+    return kb

klaude_code/ui/modes/repl/renderer.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, Iterator
+
+from rich import box
+from rich.box import Box
+from rich.console import Console
+from rich.spinner import Spinner
+from rich.status import Status
+from rich.style import Style, StyleType
+from rich.text import Text
+
+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
+from klaude_code.ui.renderers import errors as r_errors
+from klaude_code.ui.renderers import metadata as r_metadata
+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.rich import status as r_status
+from klaude_code.ui.rich.quote import Quote
+from klaude_code.ui.rich.status import 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
+    sub_agent_state: model.SubAgentState | None = None
+
+
+class REPLRenderer:
+    """Render REPL content via a Rich console."""
+
+    def __init__(self, theme: str | None = None):
+        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.session_map: dict[str, SessionStatus] = {}
+        self.current_sub_agent_color: Style | None = None
+        self.subagent_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()
+        self.session_map[session_id] = session_status
+
+    def is_sub_agent_session(self, session_id: str) -> bool:
+        return session_id in self.session_map and self.session_map[session_id].sub_agent_state is not None
+
+    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
+            return
+        self.subagent_color_index = (self.subagent_color_index + 1) % palette_size
+
+    def pick_sub_agent_color(self) -> Style:
+        self._advance_sub_agent_color_index()
+        palette = self.themes.sub_agent_colors
+        if not palette:
+            return Style()
+        return palette[self.subagent_color_index]
+
+    def get_session_sub_agent_color(self, session_id: str) -> Style:
+        status = self.session_map.get(session_id)
+        if status and status.color:
+            return status.color
+        return Style()
+
+    def box_style(self) -> Box:
+        return box.ROUNDED
+
+    @contextmanager
+    def session_print_context(self, session_id: str) -> Iterator[None]:
+        """Temporarily switch to sub-agent quote style."""
+        if session_id in self.session_map and self.session_map[session_id].color:
+            self.current_sub_agent_color = self.session_map[session_id].color
+        try:
+            yield
+        finally:
+            self.current_sub_agent_color = None
+
+    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))
+            return
+        self.console.print(*objects, style=style, end=end)
+
+    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)
+        if renderable is not None:
+            self.print(renderable)
+
+    def display_thinking(self, content: str) -> None:
+        renderable = r_thinking.render_thinking(
+            content,
+            code_theme=self.themes.code_theme,
+            style=ThemeKey.THINKING,
+        )
+        if renderable is not None:
+            self.console.push_theme(theme=self.themes.thinking_markdown_theme)
+            self.print(renderable)
+            self.console.pop_theme()
+            self.print()
+
+    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)
+                        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())
+
+    def display_developer_message(self, e: events.DeveloperMessageEvent) -> None:
+        if not r_developer.need_render_developer_message(e):
+            return
+        with self.session_print_context(e.session_id):
+            self.print(r_developer.render_developer_message(e))
+
+    def display_command_output(self, e: events.DeveloperMessageEvent) -> None:
+        if not e.item.command_output:
+            return
+        with self.session_print_context(e.session_id):
+            self.print(r_developer.render_command_output(e))
+            self.print()
+
+    def display_welcome(self, event: events.WelcomeEvent) -> None:
+        self.print(r_metadata.render_welcome(event, box_style=self.box_style()))
+
+    def display_user_message(self, event: events.UserMessageEvent) -> None:
+        self.print(r_user_input.render_user_input(event.content))
+
+    def display_task_start(self, event: events.TaskStartEvent) -> None:
+        self.register_session(event.session_id, event.sub_agent_state)
+        if event.sub_agent_state is not None:
+            with self.session_print_context(event.session_id):
+                self.print(
+                    r_sub_agent.render_sub_agent_call(
+                        event.sub_agent_state,
+                        self.get_session_sub_agent_color(event.session_id),
+                    )
+                )
+
+    def display_turn_start(self, event: events.TurnStartEvent) -> None:
+        if not self.is_sub_agent_session(event.session_id):
+            self.print()
+
+    def display_assistant_message(self, content: str) -> None:
+        renderable = r_assistant.render_assistant_message(content, code_theme=self.themes.code_theme)
+        if renderable is not None:
+            self.print(renderable)
+            self.print()
+
+    def display_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
+        with self.session_print_context(event.session_id):
+            self.print(r_metadata.render_response_metadata(event))
+            self.print()
+
+    def display_task_finish(self, event: events.TaskFinishEvent) -> None:
+        if self.is_sub_agent_session(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,
+                    )
+                )
+
+    def display_interrupt(self) -> None:
+        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())
+
+    # -------------------------------------------------------------------------
+    # Spinner control methods
+    # -------------------------------------------------------------------------
+
+    def spinner_start(self) -> None:
+        """Start the spinner animation."""
+        self._spinner.start()
+
+    def spinner_stop(self) -> None:
+        """Stop the spinner animation."""
+        self._spinner.stop()
+
+    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_renderable(self) -> Spinner:
+        """Return the spinner's renderable for embedding in other components."""
+        return self._spinner.renderable

klaude_code/ui/renderers/assistant.py

@@ -0,0 +1,21 @@
+from rich.console import RenderableType
+
+from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
+
+
+def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
+    """Render assistant message for replay history display.
+
+    Returns None if content is empty.
+    """
+    stripped = content.strip()
+    if len(stripped) == 0:
+        return None
+
+    grid = create_grid()
+    grid.add_row(
+        "•",
+        NoInsetMarkdown(stripped, code_theme=code_theme),
+    )
+    return grid

klaude_code/ui/renderers/common.py

@@ -0,0 +1,8 @@
+from rich.table import Table
+
+
+def create_grid() -> Table:
+    grid = Table.grid(padding=(0, 1))
+    grid.add_column(no_wrap=True)
+    grid.add_column(overflow="fold")
+    return grid

klaude_code/ui/renderers/developer.py

@@ -0,0 +1,158 @@
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.table import Table
+from rich.text import Text
+
+from klaude_code.protocol import commands, events, model
+from klaude_code.ui.renderers import diffs as r_diffs
+from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.renderers.tools import render_path
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.utils.common import truncate_display
+
+
+def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
+    return bool(
+        e.item.memory_paths
+        or e.item.external_file_changes
+        or e.item.todo_use
+        or e.item.at_files
+        or e.item.user_image_count
+    )
+
+
+def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
+    """Render developer message details into a single group.
+
+    Includes: memory paths, external file changes, todo reminder, @file operations.
+    Command output is excluded; render it separately via `render_command_output`.
+    """
+    parts: list[RenderableType] = []
+
+    if mp := e.item.memory_paths:
+        grid = create_grid()
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text.assemble(
+                ("Load memory ", ThemeKey.REMINDER),
+                Text(", ", ThemeKey.REMINDER).join(
+                    render_path(memory_path, ThemeKey.REMINDER_BOLD) for memory_path in mp
+                ),
+            ),
+        )
+        parts.append(grid)
+
+    if fc := e.item.external_file_changes:
+        grid = create_grid()
+        for file_path in fc:
+            grid.add_row(
+                Text("  +", style=ThemeKey.REMINDER),
+                Text.assemble(
+                    ("Read ", ThemeKey.REMINDER),
+                    render_path(file_path, ThemeKey.REMINDER_BOLD),
+                    (" after external changes", ThemeKey.REMINDER),
+                ),
+            )
+        parts.append(grid)
+
+    if e.item.todo_use:
+        grid = create_grid()
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text("Todo hasn't been updated recently", ThemeKey.REMINDER),
+        )
+        parts.append(grid)
+
+    if e.item.at_files:
+        grid = create_grid()
+        for at_file in e.item.at_files:
+            grid.add_row(
+                Text("  +", style=ThemeKey.REMINDER),
+                Text.assemble(
+                    (f"{at_file.operation} ", ThemeKey.REMINDER),
+                    render_path(at_file.path, ThemeKey.REMINDER_BOLD),
+                ),
+            )
+        parts.append(grid)
+
+    if uic := e.item.user_image_count:
+        grid = create_grid()
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text(f"Attached {uic} image{'s' if uic > 1 else ''}", style=ThemeKey.REMINDER),
+        )
+        parts.append(grid)
+
+    return Group(*parts) if parts else Text("")
+
+
+def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
+    """Render developer command output content."""
+    if not e.item.command_output:
+        return Text("")
+
+    match e.item.command_output.command_name:
+        case commands.CommandName.DIFF:
+            if e.item.content is None or len(e.item.content) == 0:
+                return Padding.indent(Text("(no changes)", style=ThemeKey.TOOL_RESULT), level=2)
+            return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
+        case commands.CommandName.HELP:
+            return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
+        case commands.CommandName.STATUS:
+            return _render_status_output(e.item.command_output)
+        case _:
+            content = e.item.content or "(no content)"
+            style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
+            return Padding.indent(Text(truncate_display(content), style=style), level=2)
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None) -> str:
+    """Format cost in USD."""
+    if cost is None:
+        return "-"
+    if cost < 0.01:
+        return f"${cost:.4f}"
+    return f"${cost:.2f}"
+
+
+def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
+    """Render session status as a two-column table with sections."""
+    if not command_output.ui_extra or not command_output.ui_extra.session_status:
+        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
+
+    status = command_output.ui_extra.session_status
+    usage = status.usage
+
+    table = Table.grid(padding=(0, 2))
+    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
+    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
+    # Token Usage section
+    table.add_row(Text("Token Usage", style="bold"), "")
+    table.add_row("Input Tokens", _format_tokens(usage.input_tokens))
+    if usage.cached_tokens > 0:
+        table.add_row("Cached Tokens", _format_tokens(usage.cached_tokens))
+    if usage.reasoning_tokens > 0:
+        table.add_row("Reasoning Tokens", _format_tokens(usage.reasoning_tokens))
+    table.add_row("Output Tokens", _format_tokens(usage.output_tokens))
+    table.add_row("Total Tokens", _format_tokens(usage.total_tokens))
+
+    # Cost section
+    if usage.total_cost is not None:
+        table.add_row("", "")  # Empty line
+        table.add_row(Text("Cost", style="bold"), "")
+        table.add_row("Input Cost", _format_cost(usage.input_cost))
+        if usage.cache_read_cost is not None and usage.cache_read_cost > 0:
+            table.add_row("Cache Read Cost", _format_cost(usage.cache_read_cost))
+        table.add_row("Output Cost", _format_cost(usage.output_cost))
+        table.add_row("Total Cost", _format_cost(usage.total_cost))
+
+    return Padding.indent(table, level=2)