klaude-code 2.4.2__py3-none-any.whl → 2.5.1__py3-none-any.whl

klaude_code/tui/components/metadata.py

@@ -32,51 +32,40 @@ def _render_task_metadata_block(
     currency_symbol = "¥" if currency == "CNY" else "$"
 
     # First column: mark only
-    mark = Text("└", style=ThemeKey.METADATA_DIM) if is_sub_agent else Text("⇅", style=ThemeKey.METADATA)
+    mark = Text("└", style=ThemeKey.METADATA_DIM) if is_sub_agent else Text("◆", style=ThemeKey.METADATA)
 
-    # Second column: model@provider / tokens / cost / …
+    # Second column: model@provider description / tokens / cost / …
     content = Text()
     content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
     if metadata.provider is not None:
         content.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
             Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
         )
+    if metadata.description:
+        content.append_text(Text(" ", style=ThemeKey.METADATA)).append_text(
+            Text(metadata.description, style=ThemeKey.METADATA_DIM)
+        )
 
     # All info parts (tokens, cost, context, etc.)
     parts: list[Text] = []
 
     if metadata.usage is not None:
-        # Tokens: ↑ 37k cache 5k ↓ 907 think 45k
-        token_parts: list[Text] = [
-            Text.assemble(("↑", ThemeKey.METADATA_DIM), (format_number(metadata.usage.input_tokens), ThemeKey.METADATA))
-        ]
+        # Tokens: ↑37k ◎5k ↓907 ∿45k ⌗ 100
+        token_text = Text()
+        token_text.append("↑", style=ThemeKey.METADATA_DIM)
+        token_text.append(format_number(metadata.usage.input_tokens), style=ThemeKey.METADATA)
         if metadata.usage.cached_tokens > 0:
-            token_parts.append(
-                Text.assemble(
-                    Text("cache ", style=ThemeKey.METADATA_DIM),
-                    Text(format_number(metadata.usage.cached_tokens), style=ThemeKey.METADATA),
-                )
-            )
-        token_parts.append(
-            Text.assemble(
-                ("↓", ThemeKey.METADATA_DIM), (format_number(metadata.usage.output_tokens), ThemeKey.METADATA)
-            )
-        )
+            token_text.append("  ◎", style=ThemeKey.METADATA_DIM)
+            token_text.append(format_number(metadata.usage.cached_tokens), style=ThemeKey.METADATA)
+        token_text.append("  ↓", style=ThemeKey.METADATA_DIM)
+        token_text.append(format_number(metadata.usage.output_tokens), style=ThemeKey.METADATA)
         if metadata.usage.reasoning_tokens > 0:
-            token_parts.append(
-                Text.assemble(
-                    ("think ", ThemeKey.METADATA_DIM),
-                    (format_number(metadata.usage.reasoning_tokens), ThemeKey.METADATA),
-                )
-            )
+            token_text.append("  ∿", style=ThemeKey.METADATA_DIM)
+            token_text.append(format_number(metadata.usage.reasoning_tokens), style=ThemeKey.METADATA)
         if metadata.usage.image_tokens > 0:
-            token_parts.append(
-                Text.assemble(
-                    ("image ", ThemeKey.METADATA_DIM),
-                    (format_number(metadata.usage.image_tokens), ThemeKey.METADATA),
-                )
-            )
-        parts.append(Text(" · ").join(token_parts))
+            token_text.append("  ⌗ ", style=ThemeKey.METADATA_DIM)
+            token_text.append(format_number(metadata.usage.image_tokens), style=ThemeKey.METADATA)
+        parts.append(token_text)
 
     # Cost
     if metadata.usage is not None and metadata.usage.total_cost is not None:
@@ -87,41 +76,41 @@ def _render_task_metadata_block(
             )
         )
     if metadata.usage is not None:
-        # Context usage
+        # Context usage: 31k/168k(18.4%)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
-            # Calculate effective limit (same as Usage.context_usage_percent)
             effective_limit = (metadata.usage.context_limit or 0) - (metadata.usage.max_tokens or DEFAULT_MAX_TOKENS)
             effective_limit_str = format_number(effective_limit) if effective_limit > 0 else "?"
             parts.append(
                 Text.assemble(
-                    ("context ", ThemeKey.METADATA_DIM),
                     (context_size, ThemeKey.METADATA),
                     ("/", ThemeKey.METADATA_DIM),
                     (effective_limit_str, ThemeKey.METADATA),
-                    (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
+                    (f"({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )
             )
 
-        # TPS
+        # TPS: 45.2tps
         if metadata.usage.throughput_tps is not None:
             parts.append(
                 Text.assemble(
-                    (f"{metadata.usage.throughput_tps:.1f} ", ThemeKey.METADATA),
-                    ("avg-tps", ThemeKey.METADATA_DIM),
+                    (f"{metadata.usage.throughput_tps:.1f}", ThemeKey.METADATA),
+                    ("tps", ThemeKey.METADATA_DIM),
                 )
             )
 
-        # First token latency
+        # First token latency: 100ms-ftl / 2.1s-ftl
         if metadata.usage.first_token_latency_ms is not None:
+            ftl_ms = metadata.usage.first_token_latency_ms
+            ftl_str = f"{ftl_ms / 1000:.1f}s" if ftl_ms >= 1000 else f"{ftl_ms:.0f}ms"
             parts.append(
                 Text.assemble(
-                    (f"{metadata.usage.first_token_latency_ms:.0f}", ThemeKey.METADATA),
-                    ("ms avg-ftl", ThemeKey.METADATA_DIM),
+                    (ftl_str, ThemeKey.METADATA),
+                    ("-ftl", ThemeKey.METADATA_DIM),
                 )
             )
 
-    # Duration
+    # Duration: 12.5s
     if show_context_and_time and metadata.task_duration_s is not None:
         parts.append(
             Text.assemble(
@@ -130,18 +119,19 @@ def _render_task_metadata_block(
             )
         )
 
-    # Turn count
+    # Turn count: 1step / 3steps
     if show_context_and_time and metadata.turn_count > 0:
+        suffix = "step" if metadata.turn_count == 1 else "steps"
         parts.append(
             Text.assemble(
                 (str(metadata.turn_count), ThemeKey.METADATA),
-                (" turns", ThemeKey.METADATA_DIM),
+                (suffix, ThemeKey.METADATA_DIM),
             )
         )
 
     if parts:
-        content.append_text(Text(" · ", style=ThemeKey.METADATA_DIM))
-        content.append_text(Text(" · ", style=ThemeKey.METADATA_DIM).join(parts))
+        content.append_text(Text("  ", style=ThemeKey.METADATA_DIM))
+        content.append_text(Text("  ", style=ThemeKey.METADATA_DIM).join(parts))
 
     grid.add_row(mark, content)
     return grid if not is_sub_agent else Padding(grid, (0, 0, 0, 2))
@@ -151,6 +141,9 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     """Render task metadata including main agent and sub-agents."""
     renderables: list[RenderableType] = []
 
+    if e.cancelled:
+        renderables.append(Text())
+
     renderables.append(
         _render_task_metadata_block(e.metadata.main_agent, is_sub_agent=False, show_context_and_time=True)
     )
@@ -176,10 +169,9 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
             ("Σ ", ThemeKey.METADATA_DIM),
             ("total ", ThemeKey.METADATA_DIM),
             (currency_symbol, ThemeKey.METADATA_DIM),
-            (f"{total_cost:.4f}", ThemeKey.METADATA),
+            (f"{total_cost:.4f}", ThemeKey.METADATA_DIM),
         )
-        grid = create_grid()
-        grid.add_row(Text(" ", style=ThemeKey.METADATA_DIM), total_line)
-        renderables.append(Padding(grid, (0, 0, 0, 2)))
+
+        renderables.append(Padding(total_line, (0, 0, 0, 2)))
 
     return Group(*renderables)

klaude_code/tui/components/rich/markdown.py

@@ -61,10 +61,8 @@ class Divider(MarkdownElement):
 
 class MarkdownTable(TableElement):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        # rich.box.MARKDOWN intentionally includes a blank top/bottom edge row. Rather than
-        # post-processing rendered segments, disable outer edges to avoid emitting those rows.
         table = Table(
-            box=box.MARKDOWN,
+            box=box.MINIMAL,
             show_edge=False,
             border_style=console.get_style("markdown.table.border"),
         )

klaude_code/tui/components/rich/theme.py

@@ -54,7 +54,7 @@ LIGHT_PALETTE = Palette(
     grey3="#c4ced4",
     grey_green="#96a096",
     purple="#5f5fb7",
-    lavender="#5f87af",
+    lavender="#7878b0",
     diff_add="#2e5a32 on #dafbe1",
     diff_add_char="#2e5a32 on #aceebb",
     diff_remove="#82071e on #ffecec",
@@ -276,7 +276,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.TOOL_PARAM.value: palette.green,
                 ThemeKey.TOOL_PARAM_BOLD.value: "bold " + palette.green,
                 ThemeKey.TOOL_RESULT.value: palette.grey_green,
-                ThemeKey.TOOL_RESULT_TREE_PREFIX.value: palette.grey3 + " dim",
+                ThemeKey.TOOL_RESULT_TREE_PREFIX.value: palette.grey3,
                 ThemeKey.TOOL_RESULT_BOLD.value: "bold " + palette.grey_green,
                 ThemeKey.TOOL_RESULT_TRUNCATED.value: palette.grey1 + " dim",
                 ThemeKey.TOOL_MARK.value: "bold",

klaude_code/tui/components/tools.py

@@ -498,31 +498,6 @@ def render_mermaid_tool_result(
     return viewer
 
 
-def _extract_truncation(
-    ui_extra: model.ToolResultUIExtra | None,
-) -> model.TruncationUIExtra | None:
-    return ui_extra if isinstance(ui_extra, model.TruncationUIExtra) else None
-
-
-def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
-    """Render truncation info for the user."""
-    truncated_kb = ui_extra.truncated_length / 1024
-
-    text = Text.assemble(
-        ("Offload context to ", ThemeKey.TOOL_RESULT_TRUNCATED),
-        (ui_extra.saved_file_path, ThemeKey.TOOL_RESULT_TRUNCATED),
-        (f", {truncated_kb:.1f}KB truncated", ThemeKey.TOOL_RESULT_TRUNCATED),
-    )
-    text.no_wrap = True
-    text.overflow = "ellipsis"
-    return text
-
-
-def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra | None:
-    """Extract truncation info from a tool result event."""
-    return _extract_truncation(tr.ui_extra)
-
-
 def render_report_back_tool_call() -> RenderableType:
     return _render_tool_call_tree(mark=MARK_DONE, tool_name="Report Back", details=None)
 
@@ -659,12 +634,6 @@ def render_tool_result(
                 rendered.append(r_diffs.render_structured_diff(item, show_file_name=show_file_name))
         return wrap(Group(*rendered)) if rendered else None
 
-    # Show truncation info if output was truncated and saved to file
-    truncation_info = get_truncation_info(e)
-    if truncation_info:
-        result = render_generic_tool_result(e.result, is_error=e.is_error)
-        return wrap(Group(render_truncation_info(truncation_info), result))
-
     diff_ui = _extract_diff(e.ui_extra)
     md_ui = _extract_markdown_doc(e.ui_extra)
 

klaude_code/tui/components/welcome.py

@@ -47,12 +47,9 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
     # Use format_model_params for consistent formatting
     param_strings = format_model_params(e.llm_config)
 
-    # Check if we have sub-agent models to show
-    has_sub_agents = e.show_sub_agent_models and e.sub_agent_models
-
     # Render config items with tree-style prefixes
     for i, param_str in enumerate(param_strings):
-        is_last = i == len(param_strings) - 1 and not has_sub_agents
+        is_last = i == len(param_strings) - 1
         prefix = "└─ " if is_last else "├─ "
         panel_content.append_text(
             Text.assemble(
@@ -62,34 +59,6 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
             )
         )
 
-    # Render sub-agent models
-    if has_sub_agents:
-        # Add sub-agents header with tree prefix
-        panel_content.append_text(
-            Text.assemble(
-                ("\n", ThemeKey.WELCOME_INFO),
-                ("└─ ", ThemeKey.LINES),
-                ("sub-agents:", ThemeKey.WELCOME_INFO),
-            )
-        )
-        sub_agent_items = list(e.sub_agent_models.items())
-        max_type_len = max(len(t) for t in e.sub_agent_models)
-        for i, (sub_agent_type, sub_llm_config) in enumerate(sub_agent_items):
-            is_last = i == len(sub_agent_items) - 1
-            prefix = "└─ " if is_last else "├─ "
-            panel_content.append_text(
-                Text.assemble(
-                    ("\n", ThemeKey.WELCOME_INFO),
-                    ("   ", ThemeKey.WELCOME_INFO),  # Indentation for sub-items
-                    (prefix, ThemeKey.LINES),
-                    (sub_agent_type.lower().ljust(max_type_len), ThemeKey.WELCOME_INFO),
-                    (": ", ThemeKey.LINES),
-                    (str(sub_llm_config.model_id), ThemeKey.WELCOME_HIGHLIGHT),
-                    (" @ ", ThemeKey.WELCOME_INFO),
-                    (sub_llm_config.provider_name, ThemeKey.WELCOME_INFO),
-                )
-            )
-
     border_style = ThemeKey.WELCOME_DEBUG_BORDER if debug_mode else ThemeKey.LINES
 
     if e.show_klaude_code_info:

klaude_code/tui/input/prompt_toolkit.py

@@ -394,17 +394,14 @@ class PromptToolkitInput(InputProviderABC):
         with contextlib.suppress(Exception):
             _patch_completion_menu_controls(self._session.app.layout.container)
 
-        # Reserve more vertical space while the model picker overlay is open.
+        # Reserve more vertical space while overlays (selector, completion menu) are open.
         # prompt_toolkit's default multiline prompt caps out at ~9 lines.
-        self._patch_prompt_height_for_model_picker()
+        self._patch_prompt_height_for_overlays()
 
         # Ensure completion menu has default selection
         self._session.default_buffer.on_completions_changed += self._select_first_completion_on_open  # pyright: ignore[reportUnknownMemberType]
 
-    def _patch_prompt_height_for_model_picker(self) -> None:
-        if self._model_picker is None and self._thinking_picker is None:
-            return
-
+    def _patch_prompt_height_for_overlays(self) -> None:
         with contextlib.suppress(Exception):
             root = self._session.app.layout.container
             input_window = _find_window_for_buffer(root, self._session.default_buffer)
@@ -417,14 +414,33 @@ class PromptToolkitInput(InputProviderABC):
                 picker_open = (self._model_picker is not None and self._model_picker.is_open) or (
                     self._thinking_picker is not None and self._thinking_picker.is_open
                 )
-                if picker_open:
-                    # Target 20 rows, but cap to the current terminal size.
+
+                try:
+                    complete_state = self._session.default_buffer.complete_state
+                    completion_open = complete_state is not None and bool(complete_state.completions)
+                except Exception:
+                    completion_open = False
+
+                try:
+                    original_height_value = original_height() if callable(original_height) else original_height
+                except Exception:
+                    original_height_value = None
+                original_height_int = original_height_value if isinstance(original_height_value, int) else None
+
+                if picker_open or completion_open:
+                    target_rows = 20 if picker_open else 14
+
+                    # Cap to the current terminal size.
                     # Leave a small buffer to avoid triggering "Window too small".
                     try:
                         rows = get_app().output.get_size().rows
                     except Exception:
                         rows = 0
-                    return max(3, min(20, rows - 2))
+
+                    expanded = max(3, min(target_rows, rows - 2))
+                    if original_height_int is not None:
+                        expanded = max(original_height_int, expanded)
+                    return expanded
 
                 if callable(original_height):
                     return original_height()

klaude_code/tui/machine.py

@@ -8,6 +8,7 @@ from klaude_code.const import (
     SIGINT_DOUBLE_PRESS_EXIT_TEXT,
     STATUS_COMPOSING_TEXT,
     STATUS_DEFAULT_TEXT,
+    STATUS_SHOW_BUFFER_LENGTH,
     STATUS_THINKING_TEXT,
 )
 from klaude_code.protocol import events, model, tools
@@ -65,17 +66,6 @@ FAST_TOOLS: frozenset[str] = frozenset(
 )
 
 
-def _should_skip_tool_activity(tool_name: str, model_id: str | None) -> bool:
-    """Check if tool activity should be skipped for non-streaming models."""
-    if model_id is None:
-        return False
-    if tool_name not in FAST_TOOLS:
-        return False
-    # Gemini and Grok models don't stream tool JSON at fine granularity
-    model_lower = model_id.lower()
-    return "gemini" in model_lower or "grok" in model_lower
-
-
 @dataclass
 class SubAgentThinkingHeaderState:
     buffer: str = ""
@@ -180,7 +170,7 @@ class ActivityState:
         if self._composing:
             text = Text()
             text.append(STATUS_COMPOSING_TEXT, style=ThemeKey.STATUS_TEXT)
-            if self._buffer_length > 0:
+            if STATUS_SHOW_BUFFER_LENGTH and self._buffer_length > 0:
                 text.append(f" ({self._buffer_length:,})", style=ThemeKey.STATUS_TEXT)
             return text
 
@@ -256,7 +246,7 @@ class SpinnerStatusState:
         base_status = self._reasoning_status or self._todo_status
 
         if base_status:
-            # Default "Reasoning ..." uses normal style; custom headers use bold italic
+            # Default "Thinking ..." uses normal style; custom headers use bold italic
             is_default_reasoning = base_status == STATUS_THINKING_TEXT
             status_style = ThemeKey.STATUS_TEXT if is_default_reasoning else ThemeKey.STATUS_TEXT_BOLD_ITALIC
             if activity_text:
@@ -299,6 +289,7 @@ class _SessionState:
     session_id: str
     sub_agent_state: model.SubAgentState | None = None
     sub_agent_thinking_header: SubAgentThinkingHeaderState | None = None
+    model_id: str | None = None
     assistant_stream_active: bool = False
     thinking_stream_active: bool = False
     assistant_char_count: int = 0
@@ -312,6 +303,23 @@ class _SessionState:
     def should_show_sub_agent_thinking_header(self) -> bool:
         return bool(self.sub_agent_state and self.sub_agent_state.sub_agent_type == "ImageGen")
 
+    @property
+    def should_extract_reasoning_header(self) -> bool:
+        """Gemini and GPT-5 models use markdown bold headers in thinking."""
+        if self.model_id is None:
+            return False
+        model_lower = self.model_id.lower()
+        return "gemini" in model_lower or "gpt-5" in model_lower
+
+    def should_skip_tool_activity(self, tool_name: str) -> bool:
+        """Check if tool activity should be skipped for non-streaming models."""
+        if self.model_id is None:
+            return False
+        if tool_name not in FAST_TOOLS:
+            return False
+        model_lower = self.model_id.lower()
+        return "gemini" in model_lower or "grok" in model_lower
+
 
 class DisplayStateMachine:
     """Simplified, session-aware REPL UI state machine.
@@ -379,6 +387,7 @@ class DisplayStateMachine:
 
             case events.TaskStartEvent() as e:
                 s.sub_agent_state = e.sub_agent_state
+                s.model_id = e.model_id
                 if not s.is_sub_agent:
                     self._set_primary_if_needed(e.session_id)
                     cmds.append(TaskClockStart())
@@ -411,6 +420,7 @@ class DisplayStateMachine:
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = True
+                s.thinking_tail = ""
                 # Ensure the status reflects that reasoning has started even
                 # before we receive any deltas (or a bold header).
                 self._spinner.set_reasoning_status(STATUS_THINKING_TEXT)
@@ -434,11 +444,13 @@ class DisplayStateMachine:
                 cmds.append(AppendThinking(session_id=e.session_id, content=e.content))
 
                 # Update reasoning status for spinner (based on bounded tail).
-                s.thinking_tail = (s.thinking_tail + e.content)[-8192:]
-                header = extract_last_bold_header(normalize_thinking_content(s.thinking_tail))
-                if header:
-                    self._spinner.set_reasoning_status(header)
-                    cmds.extend(self._spinner_update_commands())
+                # Only extract headers for models that use markdown bold headers in thinking.
+                if s.should_extract_reasoning_header:
+                    s.thinking_tail = (s.thinking_tail + e.content)[-8192:]
+                    header = extract_last_bold_header(normalize_thinking_content(s.thinking_tail))
+                    if header:
+                        self._spinner.set_reasoning_status(header)
+                        cmds.extend(self._spinner_update_commands())
 
                 return cmds
 
@@ -527,7 +539,7 @@ class DisplayStateMachine:
 
                 # Skip activity state for fast tools on non-streaming models (e.g., Gemini)
                 # to avoid flash-and-disappear effect
-                if not _should_skip_tool_activity(e.tool_name, e.model_id):
+                if not s.should_skip_tool_activity(e.tool_name):
                     tool_active_form = get_tool_active_form(e.tool_name)
                     if is_sub_agent_tool(e.tool_name):
                         self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)

{klaude_code-2.4.2.dist-info → klaude_code-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.4.2
+Version: 2.5.1
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0