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

klaude_code/ui/renderers/sub_agent.py

@@ -16,7 +16,7 @@ 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")
+    value_type = value.get("type", "any").lower()
     desc = value.get("description", "")
 
     if value_type == "object":
@@ -64,16 +64,20 @@ def render_sub_agent_result(
 
     # 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,
+        try:
+            return Panel.fit(
+                Group(
+                    Text(
+                        "use /export to view full output",
+                        style=ThemeKey.TOOL_RESULT,
+                    ),
+                    JSON(stripped_result),
                 ),
-                JSON(stripped_result),
-            ),
-            border_style=ThemeKey.LINES,
-        )
+                border_style=ThemeKey.LINES,
+            )
+        except json.JSONDecodeError:
+            # Fall back to markdown if not valid JSON
+            pass
 
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:

klaude_code/ui/renderers/thinking.py

@@ -1,3 +1,5 @@
+import re
+
 from rich.console import RenderableType
 from rich.padding import Padding
 from rich.text import Text
@@ -10,14 +12,28 @@ def thinking_prefix() -> Text:
     return Text.from_markup("[not italic]⸫[/not italic] Thinking …", style=ThemeKey.THINKING)
 
 
-def _normalize_thinking_content(content: str) -> str:
+def normalize_thinking_content(content: str) -> str:
     """Normalize thinking content for display."""
-    return (
-        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
-    )
+    text = content.rstrip()
+
+    # Weird case of Gemini 3
+    text = text.replace("\\n\\n\n\n", "")
+
+    # Fix OpenRouter OpenAI reasoning formatting where segments like
+    # "text**Title**\n\n" lose the blank line between segments.
+    # We want: "text\n**Title**\n" so that each bold title starts on
+    # its own line and uses a single trailing newline.
+    text = re.sub(r"([^\n])(\*\*[^*]+?\*\*)\n\n", r"\1  \n\n\2  \n", text)
+
+    # Remove extra newlines between back-to-back bold titles, eg
+    # "**Title1****Title2**" -> "**Title1**\n\n**Title2**".
+    text = text.replace("****", "**\n\n**")
+
+    # Compact double-newline after bold so the body text follows
+    # directly after the title line, using a markdown line break.
+    text = text.replace("**\n\n", "**  \n")
+
+    return text
 
 
 def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableType | None:
@@ -31,7 +47,7 @@ def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableT
 
     return Padding.indent(
         ThinkingMarkdown(
-            _normalize_thinking_content(content),
+            normalize_thinking_content(content),
             code_theme=code_theme,
             style=style,
         ),

klaude_code/ui/renderers/tools.py

@@ -2,7 +2,7 @@ import json
 from pathlib import Path
 from typing import Any, cast
 
-from rich.console import RenderableType
+from rich.console import Group, RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
@@ -186,14 +186,7 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
-        op_label = "Create"
-        if isinstance(file_path, str):
-            abs_path = Path(file_path)
-            if not abs_path.is_absolute():
-                abs_path = (Path().cwd() / abs_path).resolve()
-            if abs_path.exists():
-                op_label = "Overwrite"
-        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", (op_label, ThemeKey.TOOL_NAME))
+        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
         tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
@@ -386,6 +379,75 @@ def render_mermaid_tool_call(arguments: str) -> RenderableType:
     return grid
 
 
+def _truncate_url(url: str, max_length: int = 400) -> str:
+    """Truncate URL for display, preserving domain and path structure."""
+    if len(url) <= max_length:
+        return url
+    # Remove protocol for display
+    display_url = url
+    for prefix in ("https://", "http://"):
+        if display_url.startswith(prefix):
+            display_url = display_url[len(prefix) :]
+            break
+    if len(display_url) <= max_length:
+        return display_url
+    # Truncate with ellipsis
+    return display_url[: max_length - 3] + "..."
+
+
+def render_web_fetch_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("↓", ThemeKey.TOOL_MARK), " ", ("Fetch", ThemeKey.TOOL_NAME))
+
+    try:
+        payload: dict[str, str] = json.loads(arguments)
+    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
+
+    url = payload.get("url", "")
+    summary = Text(_truncate_url(url), ThemeKey.TOOL_PARAM_FILE_PATH) if url else Text("(no url)", ThemeKey.TOOL_PARAM)
+
+    grid.add_row(tool_name_column, summary)
+    return grid
+
+
+def render_web_search_tool_call(arguments: str) -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("◉", ThemeKey.TOOL_MARK), " ", ("Search", ThemeKey.TOOL_NAME))
+
+    try:
+        payload: dict[str, Any] = json.loads(arguments)
+    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
+
+    query = payload.get("query", "")
+    max_results = payload.get("max_results")
+
+    summary = Text("", ThemeKey.TOOL_PARAM)
+    if query:
+        # Truncate long queries
+        display_query = query if len(query) <= 80 else query[:77] + "..."
+        summary.append(display_query, ThemeKey.TOOL_PARAM)
+    else:
+        summary.append("(no query)", ThemeKey.TOOL_PARAM)
+
+    if isinstance(max_results, int) and max_results != 10:
+        summary.append(f" (max {max_results})", ThemeKey.TOOL_TIMEOUT)
+
+    grid.add_row(tool_name_column, summary)
+    return grid
+
+
 def render_mermaid_tool_result(tr: events.ToolResultEvent) -> RenderableType:
     from klaude_code.ui.terminal import supports_osc8_hyperlinks
 
@@ -416,16 +478,12 @@ def _extract_truncation(
 
 def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
     """Render truncation info for the user."""
-    original_kb = ui_extra.original_length / 1024
     truncated_kb = ui_extra.truncated_length / 1024
+
     text = Text.assemble(
-        ("Output truncated: ", ThemeKey.TOOL_RESULT),
-        (f"{original_kb:.1f}KB", ThemeKey.TOOL_RESULT),
-        (" total, ", ThemeKey.TOOL_RESULT),
-        (f"{truncated_kb:.1f}KB", ThemeKey.TOOL_RESULT_BOLD),
-        (" hidden\nFull output saved to ", ThemeKey.TOOL_RESULT),
-        (ui_extra.saved_file_path, ThemeKey.TOOL_RESULT),
-        ("\nUse Read with limit+offset or rg/grep to inspect", ThemeKey.TOOL_RESULT),
+        ("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),
     )
     return Padding.indent(text, level=2)
 
@@ -455,8 +513,9 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.SKILL: "Skilling",
     tools.MERMAID: "Diagramming",
     tools.MEMORY: "Memorizing",
-    tools.WEB_FETCH: "Fetching",
-    tools.REPORT_BACK: "Submitting Report",
+    tools.WEB_FETCH: "Fetching Web",
+    tools.WEB_SEARCH: "Searching Web",
+    tools.REPORT_BACK: "Reporting",
 }
 
 
@@ -512,6 +571,10 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_generic_tool_call(e.tool_name, e.arguments, "◈")
         case tools.REPORT_BACK:
             return render_report_back_tool_call()
+        case tools.WEB_FETCH:
+            return render_web_fetch_tool_call(e.arguments)
+        case tools.WEB_SEARCH:
+            return render_web_search_tool_call(e.arguments)
         case _:
             return render_generic_tool_call(e.tool_name, e.arguments)
 
@@ -540,7 +603,7 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
     # Show truncation info if output was truncated and saved to file
     truncation_info = get_truncation_info(e)
     if truncation_info:
-        return render_truncation_info(truncation_info)
+        return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
 
     diff_text = _extract_diff_text(e.ui_extra)
 

klaude_code/ui/rich/code_panel.py

@@ -0,0 +1,112 @@
+"""A panel that only has top and bottom borders, no left/right borders or padding."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.console import ConsoleRenderable, RichCast
+from rich.jupyter import JupyterMixin
+from rich.measure import Measurement, measure_renderables
+from rich.segment import Segment
+from rich.style import StyleType
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+# Box drawing characters
+TOP_LEFT = "┌"  # ┌
+TOP_RIGHT = "┐"  # ┐
+BOTTOM_LEFT = "└"  # └
+BOTTOM_RIGHT = "┘"  # ┘
+HORIZONTAL = "─"  # ─
+
+
+class CodePanel(JupyterMixin):
+    """A panel with only top and bottom borders, no left/right borders.
+
+    This is designed for code blocks where you want easy copy-paste without
+    picking up border characters on the sides.
+
+    Example:
+        >>> console.print(CodePanel(Syntax(code, "python")))
+
+    Renders as:
+        ┌──────────────────────────┐
+        code line 1
+        code line 2
+        └──────────────────────────┘
+    """
+
+    def __init__(
+        self,
+        renderable: ConsoleRenderable | RichCast | str,
+        *,
+        border_style: StyleType = "none",
+        expand: bool = False,
+        padding: int = 1,
+    ) -> None:
+        """Initialize the CodePanel.
+
+        Args:
+            renderable: A console renderable object.
+            border_style: The style of the border. Defaults to "none".
+            expand: If True, expand to fill available width. Defaults to False.
+            padding: Left/right padding for content. Defaults to 1.
+        """
+        self.renderable = renderable
+        self.border_style = border_style
+        self.expand = expand
+        self.padding = padding
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        border_style = console.get_style(self.border_style)
+        max_width = options.max_width
+        pad = self.padding
+
+        # Measure the content width (account for padding)
+        if self.expand:
+            content_width = max_width - pad * 2
+        else:
+            content_width = console.measure(self.renderable, options=options.update(width=max_width - pad * 2)).maximum
+            content_width = min(content_width, max_width - pad * 2)
+
+        # Render content lines
+        child_options = options.update(width=content_width)
+        lines = console.render_lines(self.renderable, child_options)
+
+        # Calculate border width based on content width + padding
+        border_width = content_width + pad * 2
+
+        new_line = Segment.line()
+        pad_segment = Segment(" " * pad) if pad > 0 else None
+
+        # Top border: ┌───...───┐
+        top_border = (
+            TOP_LEFT + (HORIZONTAL * (border_width - 2)) + TOP_RIGHT if border_width >= 2 else HORIZONTAL * border_width
+        )
+        yield Segment(top_border, border_style)
+        yield new_line
+
+        # Content lines with padding
+        for line in lines:
+            if pad_segment:
+                yield pad_segment
+            yield from line
+            if pad_segment:
+                yield pad_segment
+            yield new_line
+
+        # Bottom border: └───...───┘
+        bottom_border = (
+            BOTTOM_LEFT + (HORIZONTAL * (border_width - 2)) + BOTTOM_RIGHT
+            if border_width >= 2
+            else HORIZONTAL * border_width
+        )
+        yield Segment(bottom_border, border_style)
+        yield new_line
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        if self.expand:
+            return Measurement(options.max_width, options.max_width)
+        width = measure_renderables(console, options, [self.renderable]).maximum + self.padding * 2
+        return Measurement(width, width)

klaude_code/ui/rich/markdown.py

@@ -7,11 +7,9 @@ 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
-from rich.panel import Panel
 from rich.rule import Rule
 from rich.spinner import Spinner
 from rich.style import Style
@@ -20,6 +18,7 @@ from rich.text import Text
 from rich.theme import Theme
 
 from klaude_code import const
+from klaude_code.ui.rich.code_panel import CodePanel
 
 
 class NoInsetCodeBlock(CodeBlock):
@@ -34,7 +33,7 @@ class NoInsetCodeBlock(CodeBlock):
             word_wrap=True,
             padding=(0, 0),
         )
-        yield Panel.fit(syntax, padding=(0, 0), box=box.HORIZONTALS, border_style="markdown.code.border")
+        yield CodePanel(syntax, border_style="markdown.code.border")
 
 
 class ThinkingCodeBlock(CodeBlock):
@@ -43,7 +42,7 @@ class ThinkingCodeBlock(CodeBlock):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
         text = Text(code, "markdown.code.block")
-        yield text
+        yield CodePanel(text, border_style="markdown.code.border")
 
 
 class LeftHeading(Heading):

klaude_code/ui/rich/status.py

@@ -21,15 +21,20 @@ from klaude_code.ui.terminal.color import get_last_terminal_background_rgb
 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
@@ -172,15 +177,34 @@ def _breathing_style(console: Console, base_style: Style, intensity: float) -> S
 
 
 class ShimmerStatusText:
-    """Renderable status line with shimmer effect on the main text and hint."""
+    """Renderable status line with shimmer effect on the main text and hint.
 
-    def __init__(self, main_text: str | Text, main_style: ThemeKey) -> None:
+    Supports optional right-aligned text that stays fixed at the right edge.
+    """
+
+    def __init__(self, main_text: str | Text, main_style: ThemeKey, right_text: Text | None = None) -> None:
         self._main_text = main_text if isinstance(main_text, Text) else Text(main_text)
         self._main_style = main_style
         self._hint_text = Text(const.STATUS_HINT_TEXT)
         self._hint_style = ThemeKey.STATUS_HINT
+        self._right_text = right_text
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        left_text = self._render_left_text(console)
+
+        if self._right_text is None:
+            yield left_text
+            return
+
+        # Use Table.grid to create left-right aligned layout
+        table = Table.grid(expand=True)
+        table.add_column(justify="left", ratio=1)
+        table.add_column(justify="right")
+        table.add_row(left_text, self._right_text)
+        yield table
+
+    def _render_left_text(self, console: Console) -> Text:
+        """Render the left part with shimmer effect."""
         result = Text()
         main_style = console.get_style(str(self._main_style))
         hint_style = console.get_style(str(self._hint_style))
@@ -198,7 +222,7 @@ class ShimmerStatusText:
             style = _shimmer_style(console, base_style, intensity)
             result.append(ch, style=style)
 
-        yield result
+        return result
 
 
 def spinner_name() -> str:

klaude_code/ui/rich/theme.py

@@ -86,6 +86,7 @@ class ThemeKey(str, Enum):
     # SPINNER_STATUS
     SPINNER_STATUS = "spinner.status"
     SPINNER_STATUS_TEXT = "spinner.status.text"
+    SPINNER_STATUS_TEXT_BOLD = "spinner.status.text.bold"
     # STATUS
     STATUS_HINT = "status.hint"
     # USER_INPUT
@@ -103,6 +104,7 @@ class ThemeKey(str, Enum):
     TOOL_PARAM = "tool.param"
     TOOL_PARAM_BOLD = "tool.param.bold"
     TOOL_RESULT = "tool.result"
+    TOOL_RESULT_TRUNCATED = "tool.result.truncated"
     TOOL_RESULT_BOLD = "tool.result.bold"
     TOOL_MARK = "tool.mark"
     TOOL_APPROVED = "tool.approved"
@@ -181,6 +183,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 # SPINNER_STATUS
                 ThemeKey.SPINNER_STATUS.value: palette.blue,
                 ThemeKey.SPINNER_STATUS_TEXT.value: palette.blue,
+                ThemeKey.SPINNER_STATUS_TEXT_BOLD.value: "bold " + palette.blue,
                 # STATUS
                 ThemeKey.STATUS_HINT.value: palette.grey2,
                 # REMINDER
@@ -194,6 +197,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.TOOL_PARAM_BOLD.value: "bold " + palette.green,
                 ThemeKey.TOOL_RESULT.value: palette.grey_green,
                 ThemeKey.TOOL_RESULT_BOLD.value: "bold " + palette.grey_green,
+                ThemeKey.TOOL_RESULT_TRUNCATED.value: palette.yellow,
                 ThemeKey.TOOL_MARK.value: "bold",
                 ThemeKey.TOOL_APPROVED.value: palette.green + " bold reverse",
                 ThemeKey.TOOL_REJECTED.value: palette.red + " bold reverse",
@@ -243,11 +247,15 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.hr": palette.grey3,
                 "markdown.item.bullet": palette.grey2,
                 "markdown.item.number": palette.grey2,
+                "markdown.link": "underline " + palette.blue,
+                "markdown.link_url": "underline " + palette.blue,
             }
         ),
         thinking_markdown_theme=Theme(
             styles={
                 "markdown.code": palette.grey1 + " italic on " + palette.text_background,
+                "markdown.code.block": palette.grey1,
+                "markdown.code.border": palette.grey3,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2.border": palette.grey3,
@@ -256,7 +264,8 @@ 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.link": "underline " + palette.blue,
+                "markdown.link_url": "underline " + palette.blue,
                 "markdown.strong": "bold italic " + palette.grey1,
             }
         ),