klaude-code 1.2.14__py3-none-any.whl → 1.2.16__py3-none-any.whl

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,161 +25,133 @@ 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 cache 5k ↓ 907 think 45k
+        token_parts: list[Text] = [
+            Text.assemble(
+                ("↑ ", 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(
+                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)
+            )
+        )
         if metadata.usage.reasoning_tokens > 0:
-            parts2.append(
+            token_parts.append(
                 Text.assemble(
-                    ("thinking", ThemeKey.METADATA_DIM),
-                    (":", ThemeKey.METADATA_DIM),
-                    (
-                        format_number(metadata.usage.reasoning_tokens),
-                        ThemeKey.METADATA_DIM,
-                    ),
+                    ("think ", ThemeKey.METADATA_DIM),
+                    (format_number(metadata.usage.reasoning_tokens), ThemeKey.METADATA),
                 )
             )
+        parts.append(Text(" · ").join(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)
 

klaude_code/ui/renderers/sub_agent.py

@@ -1,6 +1,8 @@
 import json
+from typing import Any, cast
 
 from rich.console import Group, RenderableType
+from rich.json import JSON
 from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
@@ -12,20 +14,67 @@ from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 
+def _compact_schema_value(value: dict[str, Any]) -> str | list[Any] | dict[str, Any]:
+    """Convert a JSON Schema value to compact representation."""
+    value_type = value.get("type", "any")
+    desc = value.get("description", "")
+
+    if value_type == "object":
+        props = value.get("properties", {})
+        return {k: _compact_schema_value(v) for k, v in props.items()}
+    elif value_type == "array":
+        items = value.get("items", {})
+        # If items have no description, use the array's description
+        if desc and not items.get("description"):
+            items = {**items, "description": desc}
+        return [_compact_schema_value(items)]
+    else:
+        if desc:
+            return f"{value_type} // {desc}"
+        return value_type
+
+
+def _compact_schema(schema: dict[str, Any]) -> dict[str, Any] | list[Any] | str:
+    """Convert JSON Schema to compact representation for display."""
+    return _compact_schema_value(schema)
+
+
 def render_sub_agent_call(e: model.SubAgentState, style: Style | None = None) -> RenderableType:
     """Render sub-agent tool call header and prompt body."""
     desc = Text(
         f" {e.sub_agent_desc} ",
         style=Style(color=style.color if style else None, bold=True, reverse=True),
     )
-    return Group(
+    elements: list[RenderableType] = [
         Text.assemble((e.sub_agent_type, ThemeKey.TOOL_NAME), " ", desc),
         Text(e.sub_agent_prompt, style=style or ""),
-    )
+    ]
+    if e.output_schema:
+        elements.append(Text("\nExpected Output Format JSON:", style=style or ""))
+        compact = _compact_schema(e.output_schema)
+        schema_text = json.dumps(compact, ensure_ascii=False, indent=2)
+        elements.append(JSON(schema_text))
+    return Group(*elements)
 
 
-def render_sub_agent_result(result: str, *, code_theme: str, style: Style | None = None) -> RenderableType:
+def render_sub_agent_result(
+    result: str, *, code_theme: str, style: Style | None = None, has_structured_output: bool = False
+) -> RenderableType:
     stripped_result = result.strip()
+
+    # Use rich JSON for structured output
+    if has_structured_output:
+        return Panel.fit(
+            Group(
+                Text(
+                    "use /export to view full output",
+                    style=ThemeKey.TOOL_RESULT,
+                ),
+                JSON(stripped_result),
+            ),
+            border_style=ThemeKey.LINES,
+        )
+
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
         hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES
@@ -53,6 +102,7 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
         return None
     description = profile.name
     prompt = ""
+    output_schema: dict[str, Any] | None = None
     if e.arguments:
         try:
             payload: dict[str, object] = json.loads(e.arguments)
@@ -64,8 +114,14 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
         prompt_value = payload.get("prompt") or payload.get("task")
         if isinstance(prompt_value, str):
             prompt = prompt_value.strip()
+        # Extract output_schema if profile supports it
+        if profile.output_schema_arg:
+            schema_value = payload.get(profile.output_schema_arg)
+            if isinstance(schema_value, dict):
+                output_schema = cast(dict[str, Any], schema_value)
     return model.SubAgentState(
         sub_agent_type=profile.name,
         sub_agent_desc=description,
         sub_agent_prompt=prompt,
+        output_schema=output_schema,
     )

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
 
 
@@ -16,7 +16,7 @@ def _normalize_thinking_content(content: str) -> str:
         content.rstrip()
         .replace("**\n\n", "**  \n")
         .replace("\\n\\n\n\n", "")  # Weird case of Gemini 3
-        .replace("****", "**\n\n**")  # remove extra newlines after bold titles
+        .replace("****", "**\n\n**")  # Remove extra newlines after bold titles
     )
 
 
@@ -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,12 +1,13 @@
 import json
 from pathlib import Path
+from typing import Any, cast
 
 from rich.console import RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
 from klaude_code import const
-from klaude_code.protocol import events, model
+from klaude_code.protocol import events, model, tools
 from klaude_code.protocol.sub_agent import is_sub_agent_tool as _is_sub_agent_tool
 from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid
@@ -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))
@@ -391,35 +435,28 @@ def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra |
     return _extract_truncation(tr.ui_extra)
 
 
-# Tool name to mark mapping
-_TOOL_MARKS: dict[str, str] = {
-    "Read": "←",
-    "Edit": "→",
-    "Write": "→",
-    "MultiEdit": "→",
-    "Bash": ">",
-    "apply_patch": "→",
-    "TodoWrite": "◎",
-    "update_plan": "◎",
-    "Mermaid": "⧉",
-    "Memory": "★",
-    "Skill": "◈",
-}
+def render_report_back_tool_call() -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("✔", ThemeKey.TOOL_MARK), " ", ("Report Back", ThemeKey.TOOL_NAME))
+    grid.add_row(tool_name_column, "")
+    return grid
+
 
 # Tool name to active form mapping (for spinner status)
 _TOOL_ACTIVE_FORM: dict[str, str] = {
-    "Bash": "Bashing",
-    "apply_patch": "Patching",
-    "Edit": "Editing",
-    "MultiEdit": "Editing",
-    "Read": "Reading",
-    "Write": "Writing",
-    "TodoWrite": "Planning",
-    "update_plan": "Planning",
-    "Skill": "Skilling",
-    "Mermaid": "Diagramming",
-    "Memory": "Memorizing",
-    "WebFetch": "Fetching",
+    tools.BASH: "Bashing",
+    tools.APPLY_PATCH: "Patching",
+    tools.EDIT: "Editing",
+    tools.MULTI_EDIT: "Editing",
+    tools.READ: "Reading",
+    tools.WRITE: "Writing",
+    tools.TODO_WRITE: "Planning",
+    tools.UPDATE_PLAN: "Planning",
+    tools.SKILL: "Skilling",
+    tools.MERMAID: "Diagramming",
+    tools.MEMORY: "Memorizing",
+    tools.WEB_FETCH: "Fetching",
+    tools.REPORT_BACK: "Submitting Report",
 }
 
 
@@ -446,7 +483,6 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
 
     Returns a Rich Renderable or None if the tool call should not be rendered.
     """
-    from klaude_code.protocol import tools
 
     if is_sub_agent_tool(e.tool_name):
         return None
@@ -461,7 +497,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:
@@ -474,6 +510,8 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_memory_tool_call(e.arguments)
         case tools.SKILL:
             return render_generic_tool_call(e.tool_name, e.arguments, "◈")
+        case tools.REPORT_BACK:
+            return render_report_back_tool_call()
         case _:
             return render_generic_tool_call(e.tool_name, e.arguments)
 
@@ -489,7 +527,6 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
 
     Returns a Rich Renderable or None if the tool result should not be rendered.
     """
-    from klaude_code.protocol import tools
     from klaude_code.ui.renderers import errors as r_errors
 
     if is_sub_agent_tool(e.tool_name):