klaude-code 1.2.8__py3-none-any.whl → 1.2.9__py3-none-any.whl

klaude_code/ui/renderers/developer.py

@@ -7,6 +7,7 @@ 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.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.utils.common import truncate_display
 
@@ -100,6 +101,8 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
             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 commands.CommandName.RELEASE_NOTES:
+            return Padding.indent(NoInsetMarkdown(e.item.content or ""), level=2)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
@@ -126,34 +129,41 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 
 
 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)
+    """Render session status with total cost and per-model breakdown."""
+    if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):
+        return Text("(no status data)", style=ThemeKey.METADATA)
 
-    status = command_output.ui_extra.session_status
+    status = command_output.ui_extra
     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, usage.currency))
-        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, usage.currency))
-        table.add_row("Output Cost", _format_cost(usage.output_cost, usage.currency))
-        table.add_row("Total Cost", _format_cost(usage.total_cost, usage.currency))
+    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+
+    # Total cost line
+    table.add_row(
+        Text("Total cost:", style=ThemeKey.METADATA_BOLD),
+        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.METADATA_BOLD),
+    )
+
+    # Per-model breakdown
+    if status.by_model:
+        table.add_row(Text("Usage by model:", style=ThemeKey.METADATA_BOLD), "")
+        for meta in status.by_model:
+            model_label = meta.model_name
+            if meta.provider:
+                model_label = f"{meta.model_name} ({meta.provider.lower().replace(' ', '-')})"
+
+            if meta.usage:
+                usage_detail = (
+                    f"{_format_tokens(meta.usage.input_tokens)} input, "
+                    f"{_format_tokens(meta.usage.output_tokens)} output, "
+                    f"{_format_tokens(meta.usage.cached_tokens)} cache read, "
+                    f"{_format_tokens(meta.usage.reasoning_tokens)} thinking, "
+                    f"({_format_cost(meta.usage.total_cost, meta.usage.currency)})"
+                )
+            else:
+                usage_detail = "(no usage data)"
+            table.add_row(f"{model_label}:", usage_detail)
 
     return Padding.indent(table, level=2)

klaude_code/ui/renderers/metadata.py

@@ -7,7 +7,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.text import Text
 
-from klaude_code.protocol import events
+from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.utils.common import format_number
@@ -21,18 +21,34 @@ def _get_version() -> str:
         return "unknown"
 
 
-def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
-    metadata = e.metadata
+def _render_task_metadata_block(
+    metadata: model.TaskMetadata,
+    *,
+    indent: int = 0,
+    show_context_and_time: bool = True,
+) -> list[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).
+        show_context_and_time: Whether to show context usage percent and time.
+
+    Returns:
+        List of renderables for this metadata block.
+    """
     # Get currency symbol
     currency = metadata.usage.currency if metadata.usage else "USD"
     currency_symbol = "¥" if currency == "CNY" else "$"
 
     # Line 1: Model and Provider
-    model_text = Text()
-    model_text.append_text(Text("- ", style=ThemeKey.METADATA_BOLD)).append_text(
-        Text(metadata.model_name, style=ThemeKey.METADATA_BOLD)
+    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))
     if metadata.provider is not None:
         model_text.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
             Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
@@ -41,7 +57,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
     renderables: list[RenderableType] = [model_text]
 
     # Line 2: Token consumption, Context, TPS, Cost
-    parts: list[Text] = []
+    parts2: list[Text] = []
 
     if metadata.usage is not None:
         # Input
@@ -51,7 +67,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
         ]
         if metadata.usage.input_cost is not None:
             input_parts.append((f"({currency_symbol}{metadata.usage.input_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts.append(Text.assemble(*input_parts))
+        parts2.append(Text.assemble(*input_parts))
 
         # Cached
         if metadata.usage.cached_tokens > 0:
@@ -61,7 +77,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             ]
             if metadata.usage.cache_read_cost is not None:
                 cached_parts.append((f"({currency_symbol}{metadata.usage.cache_read_cost:.4f})", ThemeKey.METADATA_DIM))
-            parts.append(Text.assemble(*cached_parts))
+            parts2.append(Text.assemble(*cached_parts))
 
         # Output
         output_parts: list[tuple[str, str]] = [
@@ -70,11 +86,11 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
         ]
         if metadata.usage.output_cost is not None:
             output_parts.append((f"({currency_symbol}{metadata.usage.output_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts.append(Text.assemble(*output_parts))
+        parts2.append(Text.assemble(*output_parts))
 
         # Reasoning
         if metadata.usage.reasoning_tokens > 0:
-            parts.append(
+            parts2.append(
                 Text.assemble(
                     ("thinking", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
@@ -85,14 +101,30 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
                 )
             )
 
-        # Context
-        if metadata.usage.context_usage_percent is not None:
-            parts.append(
+    # Cost
+    if metadata.usage is not None and metadata.usage.total_cost is not None:
+        parts2.append(
+            Text.assemble(
+                ("cost", ThemeKey.METADATA_DIM),
+                (":", ThemeKey.METADATA_DIM),
+                (f"{currency_symbol}{metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
+            )
+        )
+    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_window_size or 0)
+            parts3.append(
                 Text.assemble(
                     ("context", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
                     (
-                        f"{metadata.usage.context_usage_percent:.1f}%",
+                        f"{context_size}({metadata.usage.context_usage_percent:.1f}%)",
                         ThemeKey.METADATA_DIM,
                     ),
                 )
@@ -100,7 +132,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
 
         # TPS
         if metadata.usage.throughput_tps is not None:
-            parts.append(
+            parts3.append(
                 Text.assemble(
                     ("tps", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
@@ -109,8 +141,8 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             )
 
     # Duration
-    if metadata.task_duration_s is not None:
-        parts.append(
+    if show_context_and_time and metadata.task_duration_s is not None:
+        parts3.append(
             Text.assemble(
                 ("time", ThemeKey.METADATA_DIM),
                 (":", ThemeKey.METADATA_DIM),
@@ -118,19 +150,25 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             )
         )
 
-    # Cost
-    if metadata.usage is not None and metadata.usage.total_cost is not None:
-        parts.append(
-            Text.assemble(
-                ("cost", ThemeKey.METADATA_DIM),
-                (":", ThemeKey.METADATA_DIM),
-                (f"{currency_symbol}{metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
-            )
-        )
+    if parts3:
+        line2 = Text(" / ", style=ThemeKey.METADATA_DIM).join(parts3)
+        renderables.append(Padding(line2, (0, 0, 0, indent + 2)))
+
+    return renderables
+
+
+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))
+
+    # Aggregate by (model_name, provider), sorted by total_cost descending
+    sorted_items = model.TaskMetadata.aggregate_by_model(e.metadata.sub_agent_task_metadata)
 
-    if parts:
-        line2 = Text("/", style=ThemeKey.METADATA_DIM).join(parts)
-        renderables.append(Padding(line2, (0, 0, 0, 2)))
+    # Render each aggregated model block
+    for meta in sorted_items:
+        renderables.extend(_render_task_metadata_block(meta, indent=2, show_context_and_time=False))
 
     return Group(*renderables)
 

klaude_code/ui/renderers/tools.py

@@ -121,32 +121,24 @@ def render_read_tool_call(arguments: str) -> RenderableType:
     return grid
 
 
-def render_edit_tool_call(arguments: str) -> Text:
-    render_result: Text = Text.assemble(("→ ", ThemeKey.TOOL_MARK))
+def render_edit_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Edit", ThemeKey.TOOL_NAME))
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
-        render_result = (
-            render_result.append_text(Text("Edit", ThemeKey.TOOL_NAME))
-            .append_text(Text(" "))
-            .append_text(render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH))
-        )
+        arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
-        render_result = (
-            render_result.append_text(Text("Edit", ThemeKey.TOOL_NAME))
-            .append_text(Text(" "))
-            .append_text(
-                Text(
-                    arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-                    style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-                )
-            )
+        arguments_column = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    return render_result
+    grid.add_row(tool_name_column, arguments_column)
+    return grid
 
 
-def render_write_tool_call(arguments: str) -> Text:
-    render_result: Text = Text.assemble(("→ ", ThemeKey.TOOL_MARK))
+def render_write_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
@@ -157,97 +149,77 @@ def render_write_tool_call(arguments: str) -> Text:
                 abs_path = (Path().cwd() / abs_path).resolve()
             if abs_path.exists():
                 op_label = "Overwrite"
-        render_result = (
-            render_result.append_text(Text(op_label, ThemeKey.TOOL_NAME))
-            .append_text(Text(" "))
-            .append_text(render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH))
-        )
+        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", (op_label, ThemeKey.TOOL_NAME))
+        arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
-        render_result = (
-            render_result.append_text(Text("Write", ThemeKey.TOOL_NAME))
-            .append_text(Text(" "))
-            .append_text(
-                Text(
-                    arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-                    style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-                )
-            )
+        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
+        arguments_column = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    return render_result
+    grid.add_row(tool_name_column, arguments_column)
+    return grid
 
 
-def render_multi_edit_tool_call(arguments: str) -> Text:
-    render_result: Text = Text.assemble(("→ ", ThemeKey.TOOL_MARK), ("MultiEdit", ThemeKey.TOOL_NAME), " ")
+def render_multi_edit_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("MultiEdit", ThemeKey.TOOL_NAME))
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
         edits = json_dict.get("edits", [])
-        render_result = (
-            render_result.append_text(render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH))
-            .append_text(Text(" - "))
-            .append_text(Text(f"{len(edits)}", ThemeKey.TOOL_PARAM_BOLD))
-            .append_text(Text(" updates", ThemeKey.TOOL_PARAM_FILE_PATH))
+        arguments_column = Text.assemble(
+            render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH),
+            Text(" - "),
+            Text(f"{len(edits)}", ThemeKey.TOOL_PARAM_BOLD),
+            Text(" updates", ThemeKey.TOOL_PARAM_FILE_PATH),
         )
     except json.JSONDecodeError:
-        render_result = render_result.append_text(
-            Text(
-                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-            )
+        arguments_column = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    return render_result
+    grid.add_row(tool_name_column, arguments_column)
+    return grid
 
 
 def render_apply_patch_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Apply Patch", ThemeKey.TOOL_NAME))
+
     try:
         payload = json.loads(arguments)
     except json.JSONDecodeError:
-        return Text.assemble(
-            ("→ ", ThemeKey.TOOL_MARK),
-            ("Apply Patch", ThemeKey.TOOL_NAME),
-            " ",
-            Text(
-                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-            ),
+        arguments_column = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
+        grid.add_row(tool_name_column, arguments_column)
+        return grid
 
     patch_content = payload.get("patch", "")
-
-    grid = create_grid()
-    header = Text.assemble(("→ ", ThemeKey.TOOL_MARK), ("Apply Patch", ThemeKey.TOOL_NAME))
-    summary = Text("", ThemeKey.TOOL_PARAM)
+    arguments_column = Text("", ThemeKey.TOOL_PARAM)
 
     if isinstance(patch_content, str):
         lines = [line for line in patch_content.splitlines() if line and not line.startswith("*** Begin Patch")]
         if lines:
-            summary = Text(lines[0][: const.INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.TOOL_PARAM)
+            arguments_column = Text(lines[0][: const.INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.TOOL_PARAM)
     else:
-        summary = Text(
+        arguments_column = Text(
             str(patch_content)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
             ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
 
-    if summary.plain:
-        grid.add_row(header, summary)
-    else:
-        grid.add_row(header, Text("", ThemeKey.TOOL_PARAM))
-
+    grid.add_row(tool_name_column, arguments_column)
     return grid
 
 
 def render_todo(tr: events.ToolResultEvent) -> RenderableType:
-    if tr.ui_extra is None:
-        return Text.assemble(
-            ("  ✘", ThemeKey.ERROR_BOLD),
-            " ",
-            Text("(no content)", style=ThemeKey.ERROR),
-        )
-    if tr.ui_extra.type != model.ToolResultUIExtraType.TODO_LIST or tr.ui_extra.todo_list is None:
+    if not isinstance(tr.ui_extra, model.TodoListUIExtra):
         return Text.assemble(
             ("  ✘", ThemeKey.ERROR_BOLD),
             " ",
-            Text("(invalid ui_extra)", style=ThemeKey.ERROR),
+            Text("(no content)" if tr.ui_extra is None else "(invalid ui_extra)", style=ThemeKey.ERROR),
         )
 
     ui_extra = tr.ui_extra.todo_list
@@ -283,11 +255,9 @@ def render_generic_tool_result(result: str, *, is_error: bool = False) -> Render
 def _extract_mermaid_link(
     ui_extra: model.ToolResultUIExtra | None,
 ) -> model.MermaidLinkUIExtra | None:
-    if ui_extra is None:
-        return None
-    if ui_extra.type != model.ToolResultUIExtraType.MERMAID_LINK:
-        return None
-    return ui_extra.mermaid_link
+    if isinstance(ui_extra, model.MermaidLinkUIExtra):
+        return ui_extra
+    return None
 
 
 def render_memory_tool_call(arguments: str) -> RenderableType:
@@ -380,11 +350,9 @@ def render_mermaid_tool_result(tr: events.ToolResultEvent) -> RenderableType:
 def _extract_truncation(
     ui_extra: model.ToolResultUIExtra | None,
 ) -> model.TruncationUIExtra | None:
-    if ui_extra is None:
-        return None
-    if ui_extra.type != model.ToolResultUIExtraType.TRUNCATION:
-        return None
-    return ui_extra.truncation
+    if isinstance(ui_extra, model.TruncationUIExtra):
+        return ui_extra
+    return None
 
 
 def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
@@ -496,9 +464,7 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
 
 
 def _extract_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if ui_extra is None:
-        return None
-    if ui_extra.type == model.ToolResultUIExtraType.DIFF_TEXT:
+    if isinstance(ui_extra, model.DiffTextUIExtra):
         return ui_extra.diff_text
     return None
 

klaude_code/ui/rich/markdown.py

@@ -102,7 +102,6 @@ class MarkdownStream:
 
         # Defer Live creation until the first update.
         self.live: Live | None = None
-        self._live_started: bool = False
 
         # Streaming control
         self.when: float = 0.0  # Timestamp of last update
@@ -119,9 +118,10 @@ class MarkdownStream:
         self.mark: str | None = mark
         self.indent: int = max(indent, 0)
 
-        # Defer Live creation until the first update
-        self.live: Live | None = None
-        self._live_started: bool = False
+    @property
+    def _live_started(self) -> bool:
+        """Check if Live display has been started (derived from self.live)."""
+        return self.live is not None
 
     def _render_markdown_to_lines(self, text: str) -> list[str]:
         """Render markdown text to a list of lines.
@@ -214,7 +214,7 @@ class MarkdownStream:
                 console=self.console,
             )
             self.live.start()
-            self._live_started = True
+            # Note: self._live_started is now a property derived from self.live
 
         # If live rendering isn't available (e.g., after a final update), stop.
         if self.live is None:

{klaude_code-1.2.8.dist-info → klaude_code-1.2.9.dist-info}/METADATA

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