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

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

@@ -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
     )
 
 

klaude_code/ui/renderers/tools.py

@@ -7,7 +7,7 @@ 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
@@ -435,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",
 }
 
 
@@ -490,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
@@ -518,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)
 
@@ -533,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):

klaude_code/ui/rich/markdown.py

@@ -32,9 +32,9 @@ class NoInsetCodeBlock(CodeBlock):
             self.lexer_name,
             theme=self.theme,
             word_wrap=True,
-            padding=(0, 1),
+            padding=(0, 0),
         )
-        yield Panel.fit(syntax, padding=(0, 0), style="markdown.code.block", box=box.SIMPLE)
+        yield Panel.fit(syntax, padding=(0, 0), box=box.HORIZONTALS, border_style="markdown.code.border")
 
 
 class ThinkingCodeBlock(CodeBlock):
@@ -42,7 +42,7 @@ class ThinkingCodeBlock(CodeBlock):
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
-        text = Text("```\n" + code + "\n```")
+        text = Text(code, "markdown.code.block")
         yield text
 
 
@@ -52,7 +52,10 @@ class LeftHeading(Heading):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         text = self.text
         text.justify = "left"  # Override justification
-        if self.tag == "h2":
+        if self.tag == "h1":
+            h1_text = text.assemble((" ", "markdown.h1"), text, (" ", "markdown.h1"))
+            yield h1_text
+        elif self.tag == "h2":
             text.stylize(Style(bold=True, underline=False))
             yield Rule(title=text, characters="-", style="markdown.h2.border", align="left")
         else:
@@ -123,10 +126,6 @@ class MarkdownStream:
         self.when: float = 0.0  # Timestamp of last update
         self.min_delay: float = 1.0 / 20  # Minimum time between updates (20fps)
         self.live_window: int = const.MARKDOWN_STREAM_LIVE_WINDOW
-        # Track the maximum height the live window has ever reached
-        # so we only pad when it shrinks from a previous height,
-        # instead of always padding to live_window from the start.
-        self._live_window_seen_height: int = 0
 
         self.theme = theme
         self.console = console
@@ -221,18 +220,16 @@ class MarkdownStream:
         Markdown going to the console works better in terminal scrollback buffers.
         The live window doesn't play nice with terminal scrollback.
         """
-        # On the first call, start the Live renderer
         if not self._live_started:
             initial_content = self._live_renderable(Text(""), final=False)
+            # transient=False keeps final frame on screen after stop()
             self.live = Live(
                 initial_content,
                 refresh_per_second=1.0 / self.min_delay,
                 console=self.console,
             )
             self.live.start()
-            # 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:
             return
 
@@ -252,61 +249,36 @@ class MarkdownStream:
 
         num_lines = len(lines)
 
-        # How many lines have "left" the live window and are now considered stable?
-        # Or if final, consider all lines to be stable.
-        if not final:
-            num_lines = max(num_lines - self.live_window, 0)
+        # Reserve last live_window lines for Live area to keep height stable
+        num_lines = max(num_lines - self.live_window, 0)
 
-        # If there is new stable content, append only the new part
-        # Update Live window to prevent visual duplication
-        if final or num_lines > 0:
-            # Lines to append to stable area
+        # Print new stable lines above Live window
+        if num_lines > 0:
             num_printed = len(self.printed)
             to_append_count = num_lines - num_printed
 
             if to_append_count > 0:
-                # Print new stable lines above Live window
                 append_chunk = lines[num_printed:num_lines]
                 append_chunk_text = Text.from_ansi("".join(append_chunk))
                 live = self.live
                 assert live is not None
-                live.console.print(append_chunk_text)  # Print above Live area
-
-                # Track printed stable lines
+                live.console.print(append_chunk_text)
                 self.printed = lines[:num_lines]
 
-        # Handle final update cleanup
+        rest_lines = lines[num_lines:]
+
+        # Final: render remaining lines without spinner, then stop Live
         if final:
             live = self.live
             assert live is not None
-            live.update(Text(""))
+            rest = "".join(rest_lines)
+            rest_text = Text.from_ansi(rest)
+            final_renderable = self._live_renderable(rest_text, final=True)
+            live.update(final_renderable)
             live.stop()
             self.live = None
             return
 
-        # Update Live window to prevent timing issues
-        # with console.print above. We pad the live region
-        # so that its height stays stable when it shrinks
-        # from a previously reached height, avoiding spinner jitter.
-        rest_lines = lines[num_lines:]
-
-        if not final:
-            current_height = len(rest_lines)
-
-            # Update the maximum height we've seen so far for this live window.
-            if current_height > self._live_window_seen_height:
-                # Never exceed configured live_window, even if logic changes later.
-                self._live_window_seen_height = min(current_height, self.live_window)
-
-            target_height = min(self._live_window_seen_height, self.live_window)
-            if target_height > 0 and current_height < target_height:
-                # Pad only up to the maximum height we've seen so far.
-                # This keeps the Live region height stable without overshooting,
-                # which can cause the spinner to jump by a line.
-                pad_count = target_height - current_height
-                # Pad after the existing lines so spinner visually stays at the bottom.
-                rest_lines = rest_lines + ["\n"] * pad_count
-
         rest = "".join(rest_lines)
         rest = Text.from_ansi(rest)
         live = self.live

klaude_code/ui/rich/status.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 import contextlib
 import math
+import random
 import time
 
 import rich.status as rich_status
-from rich._spinners import SPINNERS
 from rich.color import Color
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.spinner import Spinner as RichSpinner
@@ -17,18 +17,25 @@ from klaude_code import const
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.color import get_last_terminal_background_rgb
 
-BREATHING_SPINNER_NAME = "dot"
+# Use an existing Rich spinner name; BreathingSpinner overrides its rendering
+BREATHING_SPINNER_NAME = "dots"
+
+# Alternating glyphs for the breathing spinner - switches at each "transparent" point
+# All glyphs are center-symmetric (point-symmetric)
+_BREATHING_SPINNER_GLYPHS_BASE = [
+    # Stars
+    "✦",
+    "✶",
+    "✲",
+    "⏺",
+    "◆",
+    "❖",
+]
+
+# Shuffle glyphs on module load for variety across sessions
+BREATHING_SPINNER_GLYPHS = _BREATHING_SPINNER_GLYPHS_BASE.copy()
+random.shuffle(BREATHING_SPINNER_GLYPHS)
 
-SPINNERS.update(
-    {
-        BREATHING_SPINNER_NAME: {
-            "interval": 100,
-            # Frames content is ignored by the custom breathing spinner implementation,
-            # but we keep a single-frame list for correct width measurement.
-            "frames": ["⏺"],
-        }
-    }
-)
 
 _process_start: float | None = None
 
@@ -126,6 +133,17 @@ def _breathing_intensity() -> float:
     return 0.5 * (1.0 - math.cos(2.0 * math.pi * phase))
 
 
+def _breathing_glyph() -> str:
+    """Get the current glyph for the breathing spinner.
+
+    Alternates between glyphs at each breath cycle (when intensity reaches 0).
+    """
+    period = max(const.SPINNER_BREATH_PERIOD_SECONDS, 0.1)
+    elapsed = _elapsed_since_start()
+    cycle = int(elapsed / period)
+    return BREATHING_SPINNER_GLYPHS[cycle % len(BREATHING_SPINNER_GLYPHS)]
+
+
 def _breathing_style(console: Console, base_style: Style, intensity: float) -> Style:
     """Blend a base style's foreground color toward terminal background.
 
@@ -159,7 +177,7 @@ class ShimmerStatusText:
     def __init__(self, main_text: str | Text, main_style: ThemeKey) -> None:
         self._main_text = main_text if isinstance(main_text, Text) else Text(main_text)
         self._main_style = main_style
-        self._hint_text = Text(" (esc to interrupt)")
+        self._hint_text = Text(const.STATUS_HINT_TEXT)
         self._hint_style = ThemeKey.STATUS_HINT
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
@@ -219,7 +237,7 @@ class BreathingSpinner(RichSpinner):
         intensity = _breathing_intensity()
         style = _breathing_style(console, base_style, intensity)
 
-        glyph = self.frames[0] if self.frames else "⏺"
+        glyph = _breathing_glyph()
         frame = Text(glyph, style=style)
 
         if not self.text:

klaude_code/ui/rich/theme.py

@@ -29,7 +29,7 @@ class Palette:
 LIGHT_PALETTE = Palette(
     red="red",
     yellow="yellow",
-    green="spring_green4",
+    green="#00875f",
     cyan="cyan",
     blue="#3078C5",
     orange="#d77757",
@@ -38,8 +38,8 @@ LIGHT_PALETTE = Palette(
     grey2="#93a4b1",
     grey3="#c4ced4",
     grey_green="#96a096",
-    purple="slate_blue3",
-    lavender="steel_blue",
+    purple="#5f5fd7",
+    lavender="#5f87af",
     diff_add="#2e5a32 on #e8f5e9",
     diff_remove="#5a2e32 on #ffebee",
     code_theme="ansi_light",
@@ -47,11 +47,11 @@ LIGHT_PALETTE = Palette(
 )
 
 DARK_PALETTE = Palette(
-    red="indian_red",
+    red="#d75f5f",
     yellow="yellow",
-    green="sea_green3",
+    green="#5fd787",
     cyan="cyan",
-    blue="deep_sky_blue1",
+    blue="#00afff",
     orange="#e6704e",
     magenta="magenta",
     grey1="#99aabb",
@@ -234,7 +234,7 @@ def get_theme(theme: str | None = None) -> Themes:
         markdown_theme=Theme(
             styles={
                 "markdown.code": palette.purple,
-                "markdown.code.block": "on " + palette.text_background,
+                "markdown.code.border": palette.grey3,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2.border": palette.grey3,
@@ -256,6 +256,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.hr": palette.grey3,
                 "markdown.item.bullet": palette.grey2,
                 "markdown.item.number": palette.grey2,
+                "markdown.code.block": palette.grey1,
                 "markdown.strong": "bold italic " + palette.grey1,
             }
         ),

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.15
+Version: 1.2.16
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0
@@ -22,6 +22,7 @@ An minimal and opinionated code agent with multi-model support.
 ## Key Features
 - **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
 - **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
+- **Structured Sub-Agent Output**: Main agent defines output JSON schema for sub-agents; sub-agents use `report_back` tool with constrained decoding to return schema-compliant structured data.
 - **Skill System**: Extensible support for loading Claude Skills.
 - **Session Management**: Robust context preservation with resumable sessions (`--continue`).
 - **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
@@ -107,7 +108,7 @@ model_list:
     provider_routing:
       sort: throughput
 main_model: gpt-5.1-codex
-subagent_models:
+sub_agent_models:
   oracle: gpt-5.1-high
   explore: haiku
   task: sonnet