klaude-code 1.2.13__py3-none-any.whl → 1.2.15__py3-none-any.whl

klaude_code/ui/modes/repl/renderer.py

@@ -99,48 +99,21 @@ 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))
             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)
@@ -160,39 +133,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.InterruptEvent():
                         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.TaskMetadataEvent() as metadata_event:
-                    self.print(r_metadata.render_task_metadata(metadata_event))
-                    self.print()
-                case events.InterruptEvent():
-                    self.print()
-                    self.print(r_user_input.render_interrupt())
-                case events.ErrorEvent() as e:
-                    self.display_error(e)
+                        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):

klaude_code/ui/renderers/metadata.py

@@ -9,6 +9,7 @@ from rich.text import Text
 
 from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
+from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.utils.common import format_number
 
@@ -24,163 +25,123 @@ def _get_version() -> str:
 def _render_task_metadata_block(
     metadata: model.TaskMetadata,
     *,
-    indent: int = 0,
+    is_sub_agent: bool = False,
     show_context_and_time: bool = True,
-) -> list[RenderableType]:
+) -> RenderableType:
     """Render a single TaskMetadata block.
 
     Args:
         metadata: The TaskMetadata to render.
-        indent: Number of spaces to indent (0 for main, 2 for sub-agents).
+        is_sub_agent: Whether this is a sub-agent block.
         show_context_and_time: Whether to show context usage percent and time.
 
     Returns:
-        List of renderables for this metadata block.
+        A renderable for this metadata block.
     """
+    grid = create_grid()
+
     # Get currency symbol
     currency = metadata.usage.currency if metadata.usage else "USD"
     currency_symbol = "¥" if currency == "CNY" else "$"
 
-    # Line 1: Model and Provider
-    prefix = (
-        Text(" " * indent + "• ", style=ThemeKey.METADATA_BOLD)
-        if indent == 0
-        else Text(" " * indent + "└ ", style=ThemeKey.METADATA_DIM)
-    )
-    model_text = Text()
-    model_text.append_text(prefix).append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
+    # First column: mark only
+    mark = Text("└", style=ThemeKey.METADATA_DIM) if is_sub_agent else Text("•", style=ThemeKey.METADATA_BOLD)
+
+    # Second column: model@provider / tokens / cost / ...
+    content = Text()
+    content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
     if metadata.provider is not None:
-        model_text.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
+        content.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
             Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
         )
 
-    renderables: list[RenderableType] = [model_text]
-
-    # Line 2: Token consumption, Context, TPS, Cost
-    parts2: list[Text] = []
+    # All info parts (tokens, cost, context, etc.)
+    parts: list[Text] = []
 
     if metadata.usage is not None:
-        # Input
-        input_parts: list[tuple[str, str]] = [
-            ("input:", ThemeKey.METADATA_DIM),
-            (format_number(metadata.usage.input_tokens), ThemeKey.METADATA_DIM),
+        # Tokens: ↑37k c5k ↓907 r45k
+        token_parts: list[tuple[str, str]] = [
+            ("↑", ThemeKey.METADATA_DIM),
+            (format_number(metadata.usage.input_tokens), ThemeKey.METADATA),
         ]
-        if metadata.usage.input_cost is not None:
-            input_parts.append((f"({currency_symbol}{metadata.usage.input_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts2.append(Text.assemble(*input_parts))
-
-        # Cached
         if metadata.usage.cached_tokens > 0:
-            cached_parts: list[tuple[str, str]] = [
-                ("cached:", ThemeKey.METADATA_DIM),
-                (format_number(metadata.usage.cached_tokens), ThemeKey.METADATA_DIM),
-            ]
-            if metadata.usage.cache_read_cost is not None:
-                cached_parts.append((f"({currency_symbol}{metadata.usage.cache_read_cost:.4f})", ThemeKey.METADATA_DIM))
-            parts2.append(Text.assemble(*cached_parts))
-
-        # Output
-        output_parts: list[tuple[str, str]] = [
-            ("output:", ThemeKey.METADATA_DIM),
-            (format_number(metadata.usage.output_tokens), ThemeKey.METADATA_DIM),
-        ]
-        if metadata.usage.output_cost is not None:
-            output_parts.append((f"({currency_symbol}{metadata.usage.output_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts2.append(Text.assemble(*output_parts))
-
-        # Reasoning
+            token_parts.append((" c", ThemeKey.METADATA_DIM))
+            token_parts.append((format_number(metadata.usage.cached_tokens), ThemeKey.METADATA))
+        token_parts.append((" ↓", ThemeKey.METADATA_DIM))
+        token_parts.append((format_number(metadata.usage.output_tokens), ThemeKey.METADATA))
         if metadata.usage.reasoning_tokens > 0:
-            parts2.append(
-                Text.assemble(
-                    ("thinking", ThemeKey.METADATA_DIM),
-                    (":", ThemeKey.METADATA_DIM),
-                    (
-                        format_number(metadata.usage.reasoning_tokens),
-                        ThemeKey.METADATA_DIM,
-                    ),
-                )
-            )
+            token_parts.append((" r", ThemeKey.METADATA_DIM))
+            token_parts.append((format_number(metadata.usage.reasoning_tokens), ThemeKey.METADATA))
+        parts.append(Text.assemble(*token_parts))
 
     # Cost
     if metadata.usage is not None and metadata.usage.total_cost is not None:
-        parts2.append(
+        parts.append(
             Text.assemble(
-                ("cost", ThemeKey.METADATA_DIM),
-                (":", ThemeKey.METADATA_DIM),
-                (f"{currency_symbol}{metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
+                (currency_symbol, ThemeKey.METADATA_DIM),
+                (f"{metadata.usage.total_cost:.4f}", ThemeKey.METADATA),
             )
         )
-    if parts2:
-        line2 = Text(" / ", style=ThemeKey.METADATA_DIM).join(parts2)
-        renderables.append(Padding(line2, (0, 0, 0, indent + 2)))
-
-    parts3: list[Text] = []
     if metadata.usage is not None:
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
-            parts3.append(
+            parts.append(
                 Text.assemble(
-                    ("context", ThemeKey.METADATA_DIM),
-                    (":", ThemeKey.METADATA_DIM),
-                    (
-                        f"{context_size}({metadata.usage.context_usage_percent:.1f}%)",
-                        ThemeKey.METADATA_DIM,
-                    ),
+                    (context_size, ThemeKey.METADATA),
+                    (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )
             )
 
         # TPS
         if metadata.usage.throughput_tps is not None:
-            parts3.append(
+            parts.append(
                 Text.assemble(
+                    (f"{metadata.usage.throughput_tps:.1f} ", ThemeKey.METADATA),
                     ("tps", ThemeKey.METADATA_DIM),
-                    (":", ThemeKey.METADATA_DIM),
-                    (f"{metadata.usage.throughput_tps:.1f}", ThemeKey.METADATA_DIM),
                 )
             )
 
     # Duration
     if show_context_and_time and metadata.task_duration_s is not None:
-        parts3.append(
+        parts.append(
             Text.assemble(
-                ("time", ThemeKey.METADATA_DIM),
-                (":", ThemeKey.METADATA_DIM),
-                (f"{metadata.task_duration_s:.1f}s", ThemeKey.METADATA_DIM),
+                (f"{metadata.task_duration_s:.1f}", ThemeKey.METADATA),
+                ("s", ThemeKey.METADATA_DIM),
             )
         )
 
     # Turn count
     if show_context_and_time and metadata.turn_count > 0:
-        parts3.append(
+        parts.append(
             Text.assemble(
-                ("turns", ThemeKey.METADATA_DIM),
-                (":", ThemeKey.METADATA_DIM),
-                (str(metadata.turn_count), ThemeKey.METADATA_DIM),
+                (str(metadata.turn_count), ThemeKey.METADATA),
+                (" turns", ThemeKey.METADATA_DIM),
             )
         )
 
-    if parts3:
-        line2 = Text(" / ", style=ThemeKey.METADATA_DIM).join(parts3)
-        renderables.append(Padding(line2, (0, 0, 0, indent + 2)))
+    if parts:
+        content.append_text(Text(" · ", style=ThemeKey.METADATA_DIM))
+        content.append_text(Text(" · ", style=ThemeKey.METADATA_DIM).join(parts))
 
-    return renderables
+    grid.add_row(mark, content)
+    return grid if not is_sub_agent else Padding(grid, (0, 0, 0, 2))
 
 
 def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     """Render task metadata including main agent and sub-agents, aggregated by model+provider."""
     renderables: list[RenderableType] = []
 
-    renderables.extend(_render_task_metadata_block(e.metadata.main, indent=0, show_context_and_time=True))
+    renderables.append(_render_task_metadata_block(e.metadata.main, is_sub_agent=False, show_context_and_time=True))
 
     # Aggregate by (model_name, provider), sorted by total_cost descending
     sorted_items = model.TaskMetadata.aggregate_by_model(e.metadata.sub_agent_task_metadata)
 
     # Render each aggregated model block
     for meta in sorted_items:
-        renderables.extend(_render_task_metadata_block(meta, indent=2, show_context_and_time=False))
+        renderables.append(_render_task_metadata_block(meta, is_sub_agent=True, show_context_and_time=False))
 
-    return Group(*renderables)
+    return Padding(Group(*renderables), (0, 0, 0, 1))
 
 
 def render_welcome(e: events.WelcomeEvent, *, box_style: Box | None = None) -> RenderableType:

klaude_code/ui/renderers/thinking.py

@@ -2,7 +2,7 @@ from rich.console import RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
-from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.markdown import ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 
@@ -30,7 +30,7 @@ def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableT
         return None
 
     return Padding.indent(
-        NoInsetMarkdown(
+        ThinkingMarkdown(
             _normalize_thinking_content(content),
             code_theme=code_theme,
             style=style,

klaude_code/ui/renderers/tools.py

@@ -1,5 +1,6 @@
 import json
 from pathlib import Path
+from typing import Any, cast
 
 from rich.console import RenderableType
 from rich.padding import Padding
@@ -58,6 +59,49 @@ def render_generic_tool_call(tool_name: str, arguments: str, markup: str = "•"
     return grid
 
 
+def render_bash_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble((">", ThemeKey.TOOL_MARK), " ", ("Bash", ThemeKey.TOOL_NAME))
+
+    try:
+        payload_raw: Any = json.loads(arguments) if arguments else {}
+    except json.JSONDecodeError:
+        summary = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
+        grid.add_row(tool_name_column, summary)
+        return grid
+
+    if not isinstance(payload_raw, dict):
+        summary = Text(
+            str(payload_raw)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
+        grid.add_row(tool_name_column, summary)
+        return grid
+
+    payload: dict[str, object] = cast(dict[str, object], payload_raw)
+
+    summary = Text("", ThemeKey.TOOL_PARAM)
+    command = payload.get("command")
+    timeout_ms = payload.get("timeout_ms")
+
+    if isinstance(command, str) and command.strip():
+        summary.append(command.strip(), style=ThemeKey.TOOL_PARAM)
+
+    if isinstance(timeout_ms, int):
+        if summary:
+            summary.append(" ")
+        if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
+            summary.append(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
+        else:
+            summary.append(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
+
+    grid.add_row(tool_name_column, summary)
+    return grid
+
+
 def render_update_plan_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
     tool_name_column = Text.assemble(("◎", ThemeKey.TOOL_MARK), " ", ("Update Plan", ThemeKey.TOOL_NAME))
@@ -239,6 +283,10 @@ def render_todo(tr: events.ToolResultEvent) -> RenderableType:
                 mark = "✔"
                 mark_style = ThemeKey.TODO_NEW_COMPLETED_MARK if is_new_completed else ThemeKey.TODO_COMPLETED_MARK
                 text_style = ThemeKey.TODO_NEW_COMPLETED if is_new_completed else ThemeKey.TODO_COMPLETED
+            case _:
+                mark = "?"
+                mark_style = ThemeKey.TODO_PENDING_MARK
+                text_style = ThemeKey.TODO_PENDING
         text = Text(todo.content)
         text.stylize(text_style)
         todo_grid.add_row(Text(mark, style=mark_style), text)
@@ -457,7 +505,7 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
         case tools.MULTI_EDIT:
             return render_multi_edit_tool_call(e.arguments)
         case tools.BASH:
-            return render_generic_tool_call(e.tool_name, e.arguments, ">")
+            return render_bash_tool_call(e.arguments)
         case tools.APPLY_PATCH:
             return render_apply_patch_tool_call(e.arguments)
         case tools.TODO_WRITE:

klaude_code/ui/rich/markdown.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 import contextlib
 import io
 import time
+from collections.abc import Callable
 from typing import Any, ClassVar
 
+from rich import box
 from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
 from rich.live import Live
 from rich.markdown import CodeBlock, Heading, Markdown
@@ -32,7 +34,16 @@ class NoInsetCodeBlock(CodeBlock):
             word_wrap=True,
             padding=(0, 1),
         )
-        yield Panel.fit(syntax, padding=0, border_style="markdown.code.panel")
+        yield Panel.fit(syntax, padding=(0, 0), style="markdown.code.block", box=box.SIMPLE)
+
+
+class ThinkingCodeBlock(CodeBlock):
+    """A code block for thinking content that uses grey styling instead of syntax highlighting."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        code = str(self.text).rstrip()
+        text = Text("```\n" + code + "\n```")
+        yield text
 
 
 class LeftHeading(Heading):
@@ -41,15 +52,6 @@ class LeftHeading(Heading):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         text = self.text
         text.justify = "left"  # Override justification
-        # if self.tag == "h1":
-        #     from rich.panel import Panel
-        #     from rich import box
-        #     # Draw a border around h1s, but keep text left-aligned
-        #     yield Panel(
-        #         text,
-        #         box=box.SQUARE,
-        #         style="markdown.h1.border",
-        #     )
         if self.tag == "h2":
             text.stylize(Style(bold=True, underline=False))
             yield Rule(title=text, characters="-", style="markdown.h2.border", align="left")
@@ -68,6 +70,17 @@ class NoInsetMarkdown(Markdown):
     }
 
 
+class ThinkingMarkdown(Markdown):
+    """Markdown for thinking content with grey-styled code blocks and left-justified headings."""
+
+    elements: ClassVar[dict[str, type[Any]]] = {
+        **Markdown.elements,
+        "fence": ThinkingCodeBlock,
+        "code_block": ThinkingCodeBlock,
+        "heading_open": LeftHeading,
+    }
+
+
 class MarkdownStream:
     """Streaming markdown renderer that progressively displays content with a live updating window.
 
@@ -84,6 +97,7 @@ class MarkdownStream:
         spinner: Spinner | None = None,
         mark: str | None = None,
         indent: int = 0,
+        markdown_class: Callable[..., Markdown] | None = None,
     ) -> None:
         """Initialize the markdown stream.
 
@@ -93,6 +107,7 @@ class MarkdownStream:
             console (Console, optional): External console to use for rendering
             mark (str | None, optional): Marker shown before the first non-empty line when indent >= 2
             indent (int, optional): Number of spaces to indent all rendered lines on the left
+            markdown_class: Markdown class to use for rendering (defaults to NoInsetMarkdown)
         """
         self.printed: list[str] = []  # Stores lines that have already been printed
 
@@ -118,6 +133,7 @@ class MarkdownStream:
         self.spinner: Spinner | None = spinner
         self.mark: str | None = mark
         self.indent: int = max(indent, 0)
+        self.markdown_class: Callable[..., Markdown] = markdown_class or NoInsetMarkdown
 
     @property
     def _live_started(self) -> bool:
@@ -154,7 +170,7 @@ class MarkdownStream:
             width=effective_width,
         )
 
-        markdown = NoInsetMarkdown(text, **self.mdargs)
+        markdown = self.markdown_class(text, **self.mdargs)
         temp_console.print(markdown)
         output = string_io.getvalue()
 

klaude_code/ui/rich/theme.py

@@ -14,12 +14,12 @@ class Palette:
     blue: str
     orange: str
     magenta: str
-    grey_blue: str
     grey1: str
     grey2: str
     grey3: str
     grey_green: str
     purple: str
+    lavender: str
     diff_add: str
     diff_remove: str
     code_theme: str
@@ -31,19 +31,19 @@ LIGHT_PALETTE = Palette(
     yellow="yellow",
     green="spring_green4",
     cyan="cyan",
-    blue="#3678b7",
+    blue="#3078C5",
     orange="#d77757",
     magenta="magenta",
-    grey_blue="steel_blue",
     grey1="#667e90",
     grey2="#93a4b1",
     grey3="#c4ced4",
-    grey_green="#96a696",
+    grey_green="#96a096",
     purple="slate_blue3",
+    lavender="steel_blue",
     diff_add="#2e5a32 on #e8f5e9",
     diff_remove="#5a2e32 on #ffebee",
     code_theme="ansi_light",
-    text_background="#f0f0f0",
+    text_background="#e0e0e0",
 )
 
 DARK_PALETTE = Palette(
@@ -54,12 +54,12 @@ DARK_PALETTE = Palette(
     blue="deep_sky_blue1",
     orange="#e6704e",
     magenta="magenta",
-    grey_blue="steel_blue",
     grey1="#99aabb",
     grey2="#778899",
     grey3="#646464",
     grey_green="#6d8672",
     purple="#afbafe",
+    lavender="#9898b8",
     diff_add="#c8e6c9 on #2e4a32",
     diff_remove="#ffcdd2 on #4a2e32",
     code_theme="ansi_dark",
@@ -107,6 +107,7 @@ class ThemeKey(str, Enum):
     TOOL_MARK = "tool.mark"
     TOOL_APPROVED = "tool.approved"
     TOOL_REJECTED = "tool.rejected"
+    TOOL_TIMEOUT = "tool.timeout"
     # THINKING
     THINKING = "thinking"
     THINKING_BOLD = "thinking.bold"
@@ -174,9 +175,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
                 ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold reverse " + palette.blue,
                 # METADATA
-                ThemeKey.METADATA.value: palette.grey_blue,
-                ThemeKey.METADATA_DIM.value: "dim " + palette.grey_blue,
-                ThemeKey.METADATA_BOLD.value: "bold " + palette.grey_blue,
+                ThemeKey.METADATA.value: palette.lavender,
+                ThemeKey.METADATA_DIM.value: "dim " + palette.lavender,
+                ThemeKey.METADATA_BOLD.value: "bold " + palette.lavender,
                 # SPINNER_STATUS
                 ThemeKey.SPINNER_STATUS.value: palette.blue,
                 ThemeKey.SPINNER_STATUS_TEXT.value: palette.blue,
@@ -196,6 +197,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.TOOL_MARK.value: "bold",
                 ThemeKey.TOOL_APPROVED.value: palette.green + " bold reverse",
                 ThemeKey.TOOL_REJECTED.value: palette.red + " bold reverse",
+                ThemeKey.TOOL_TIMEOUT.value: palette.yellow,
                 # THINKING
                 ThemeKey.THINKING.value: "italic " + palette.grey2,
                 ThemeKey.THINKING_BOLD.value: "bold italic " + palette.grey1,
@@ -232,7 +234,7 @@ def get_theme(theme: str | None = None) -> Themes:
         markdown_theme=Theme(
             styles={
                 "markdown.code": palette.purple,
-                "markdown.code.panel": palette.grey3,
+                "markdown.code.block": "on " + palette.text_background,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2.border": palette.grey3,
@@ -245,8 +247,7 @@ def get_theme(theme: str | None = None) -> Themes:
         ),
         thinking_markdown_theme=Theme(
             styles={
-                "markdown.code": palette.grey1 + " on " + palette.text_background,
-                "markdown.code.panel": palette.grey3,
+                "markdown.code": palette.grey1 + " italic on " + palette.text_background,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2.border": palette.grey3,
@@ -265,7 +266,6 @@ def get_theme(theme: str | None = None) -> Themes:
             Style(color=palette.blue),
             Style(color=palette.purple),
             Style(color=palette.orange),
-            Style(color=palette.grey_blue),
             Style(color=palette.red),
             Style(color=palette.grey1),
             Style(color=palette.yellow),

{klaude_code-1.2.13.dist-info → klaude_code-1.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.13
+Version: 1.2.15
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0