klaude-code 1.9.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

klaude_code/ui/renderers/tools.py

@@ -4,20 +4,26 @@ from typing import Any, cast
 
 from rich import box
 from rich.console import Group, RenderableType
-from rich.padding import Padding
 from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
 
-from klaude_code import const
+from klaude_code.const import (
+    BASH_OUTPUT_PANEL_THRESHOLD,
+    INVALID_TOOL_CALL_MAX_LENGTH,
+    QUERY_DISPLAY_TRUNCATE_LENGTH,
+    URL_TRUNCATE_MAX_LENGTH,
+    WEB_SEARCH_DEFAULT_MAX_RESULTS,
+)
 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 import mermaid_viewer as r_mermaid_viewer
 from klaude_code.ui.renderers.bash_syntax import highlight_bash_command
-from klaude_code.ui.renderers.common import create_grid, truncate_display
+from klaude_code.ui.renderers.common import create_grid, truncate_middle
 from klaude_code.ui.rich.code_panel import CodePanel
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.quote import TreeQuote
 from klaude_code.ui.rich.theme import ThemeKey
 
 # Tool markers (Unicode symbols for UI display)
@@ -56,86 +62,106 @@ def render_path(path: str, style: str, is_directory: bool = False) -> Text:
     return Text(path, style=style)
 
 
-def render_generic_tool_call(tool_name: str, arguments: str, markup: str = MARK_GENERIC) -> RenderableType:
-    grid = create_grid()
+def _render_tool_call_tree(
+    *,
+    mark: str,
+    tool_name: str,
+    details: RenderableType | None,
+) -> RenderableType:
+    grid = create_grid(overflow="ellipsis")
+    grid.add_row(
+        Text(tool_name, style=ThemeKey.TOOL_NAME),
+        details if details is not None else Text(""),
+    )
+
+    return TreeQuote.for_tool_call(
+        grid,
+        mark=mark,
+        style=ThemeKey.TOOL_RESULT_TREE_PREFIX,
+        style_first=ThemeKey.TOOL_MARK,
+    )
 
-    tool_name_column = Text.assemble((markup, ThemeKey.TOOL_MARK), " ", (tool_name, ThemeKey.TOOL_NAME))
-    arguments_column = Text("")
+
+def render_generic_tool_call(tool_name: str, arguments: str, markup: str = MARK_GENERIC) -> RenderableType:
     if not arguments:
-        grid.add_row(tool_name_column, arguments_column)
-        return grid
+        return _render_tool_call_tree(mark=markup, tool_name=tool_name, details=None)
+
+    details: RenderableType
     try:
-        json_dict = json.loads(arguments)
-        if len(json_dict) == 0:
-            arguments_column = Text("", ThemeKey.TOOL_PARAM)
-        elif len(json_dict) == 1:
-            arguments_column = Text(str(next(iter(json_dict.values()))), ThemeKey.TOOL_PARAM)
-        else:
-            arguments_column = Text(
-                ", ".join([f"{k}: {v}" for k, v in json_dict.items()]),
-                ThemeKey.TOOL_PARAM,
-            )
+        payload = json.loads(arguments)
     except json.JSONDecodeError:
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
+    else:
+        if isinstance(payload, dict):
+            payload_dict = cast(dict[str, Any], payload)
+            if len(payload_dict) == 0:
+                details = Text("", ThemeKey.TOOL_PARAM)
+            elif len(payload_dict) == 1:
+                details = Text(str(next(iter(payload_dict.values()))), ThemeKey.TOOL_PARAM)
+            else:
+                details = Text(
+                    ", ".join([f"{k}: {v}" for k, v in payload_dict.items()]),
+                    ThemeKey.TOOL_PARAM,
+                )
+        else:
+            details = Text(str(payload)[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+
+    return _render_tool_call_tree(mark=markup, tool_name=tool_name, details=details)
 
 
 def render_bash_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_BASH, ThemeKey.TOOL_MARK), " ", ("Bash", ThemeKey.TOOL_NAME))
+    tool_name = "Bash"
 
     try:
         payload_raw: Any = json.loads(arguments) if arguments else {}
     except json.JSONDecodeError:
-        summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details: RenderableType = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, summary)
-        return grid
+        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=details)
 
     if not isinstance(payload_raw, dict):
-        summary = Text(
-            str(payload_raw)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            str(payload_raw)[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, summary)
-        return grid
+        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=details)
 
     payload: dict[str, object] = cast(dict[str, object], payload_raw)
 
     command = payload.get("command")
     timeout_ms = payload.get("timeout_ms")
 
-    # Build the command display with optional timeout suffix
     if isinstance(command, str) and command.strip():
         cmd_str = command.strip()
-        line_count = len(cmd_str.splitlines())
-
         highlighted = highlight_bash_command(cmd_str)
 
-        # For commands > 10 lines, use CodePanel for better display
-        if line_count > 10:
+        display_line_count = len(highlighted.plain.splitlines())
+
+        if display_line_count > BASH_OUTPUT_PANEL_THRESHOLD:
             code_panel = CodePanel(highlighted, border_style=ThemeKey.LINES)
             if isinstance(timeout_ms, int):
                 if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
                     timeout_text = Text(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
                 else:
                     timeout_text = Text(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
-                grid.add_row(tool_name_column, Group(code_panel, timeout_text))
+                return _render_tool_call_tree(
+                    mark=MARK_BASH,
+                    tool_name=tool_name,
+                    details=Group(code_panel, timeout_text),
+                )
             else:
-                grid.add_row(tool_name_column, code_panel)
-            return grid
+                return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=code_panel)
         if isinstance(timeout_ms, int):
             if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
                 highlighted.append(f" {timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
             else:
                 highlighted.append(f" {timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
-        grid.add_row(tool_name_column, highlighted)
+        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=highlighted)
     else:
         summary = Text("", ThemeKey.TOOL_PARAM)
         if isinstance(timeout_ms, int):
@@ -143,77 +169,73 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
                 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
+        bash_details: RenderableType | None = summary if summary.plain else None
+        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=bash_details)
 
 
 def render_update_plan_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_PLAN, ThemeKey.TOOL_MARK), " ", ("Update Plan", ThemeKey.TOOL_NAME))
-    explanation_column = Text("")
+    tool_name = "Update Plan"
+    details: RenderableType | None = None
 
     if arguments:
         try:
             payload = json.loads(arguments)
         except json.JSONDecodeError:
-            explanation_column = Text(
-                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            details = Text(
+                arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
                 style=ThemeKey.INVALID_TOOL_CALL_ARGS,
             )
         else:
             explanation = payload.get("explanation")
             if isinstance(explanation, str) and explanation.strip():
-                explanation_column = Text(explanation.strip(), style=ThemeKey.TODO_EXPLANATION)
+                details = Text(explanation.strip(), style=ThemeKey.TODO_EXPLANATION)
 
-    grid.add_row(tool_name_column, explanation_column)
-    return grid
+    return _render_tool_call_tree(mark=MARK_PLAN, tool_name=tool_name, details=details)
 
 
 def render_read_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    render_result: Text = Text.assemble(("Read", ThemeKey.TOOL_NAME), " ")
+    tool_name = "Read"
+    details = Text("", ThemeKey.TOOL_PARAM)
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
         limit = json_dict.get("limit", None)
         offset = json_dict.get("offset", None)
-        render_result = render_result.append_text(render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH))
+        if isinstance(file_path, str) and file_path:
+            details.append_text(render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH))
+        else:
+            details.append("(no file_path)", style=ThemeKey.TOOL_PARAM)
         if limit is not None and offset is not None:
-            render_result = (
-                render_result.append_text(Text(" "))
+            details = (
+                details.append_text(Text(" "))
                 .append_text(Text(str(offset), ThemeKey.TOOL_PARAM_BOLD))
                 .append_text(Text(":", ThemeKey.TOOL_PARAM))
                 .append_text(Text(str(offset + limit - 1), ThemeKey.TOOL_PARAM_BOLD))
             )
         elif limit is not None:
-            render_result = (
-                render_result.append_text(Text(" "))
+            details = (
+                details.append_text(Text(" "))
                 .append_text(Text("1", ThemeKey.TOOL_PARAM_BOLD))
                 .append_text(Text(":", ThemeKey.TOOL_PARAM))
                 .append_text(Text(str(limit), ThemeKey.TOOL_PARAM_BOLD))
             )
         elif offset is not None:
-            render_result = (
-                render_result.append_text(Text(" "))
+            details = (
+                details.append_text(Text(" "))
                 .append_text(Text(str(offset), ThemeKey.TOOL_PARAM_BOLD))
                 .append_text(Text(":", ThemeKey.TOOL_PARAM))
                 .append_text(Text("-", ThemeKey.TOOL_PARAM_BOLD))
             )
     except json.JSONDecodeError:
-        render_result = render_result.append_text(
-            Text(
-                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-            )
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    grid.add_row(Text(MARK_READ, ThemeKey.TOOL_MARK), render_result)
-    return grid
+    return _render_tool_call_tree(mark=MARK_READ, tool_name=tool_name, details=details)
 
 
 def render_edit_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_EDIT, ThemeKey.TOOL_MARK), " ", ("Edit", ThemeKey.TOOL_NAME))
+    tool_name = "Edit"
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
@@ -226,59 +248,52 @@ def render_edit_tool_call(arguments: str) -> RenderableType:
             replace_info.append(old_string, ThemeKey.BASH_STRING)
             replace_info.append(" → ", ThemeKey.BASH_OPERATOR)
             replace_info.append(new_string, ThemeKey.BASH_STRING)
-            arguments_column: RenderableType = Group(path_text, replace_info)
+            details: RenderableType = Group(path_text, replace_info)
         else:
-            arguments_column = path_text
+            details = path_text
     except json.JSONDecodeError:
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
+    return _render_tool_call_tree(mark=MARK_EDIT, tool_name=tool_name, details=details)
 
 
 def render_write_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
+    tool_name = "Write"
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path", "")
-        tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         # Markdown files show path in result panel, skip here to avoid duplication
         if file_path.endswith(".md"):
-            arguments_column = Text("")
+            details: RenderableType | None = None
         else:
-            arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
+            details = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
-        tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
+    return _render_tool_call_tree(mark=MARK_WRITE, tool_name=tool_name, details=details)
 
 
 def render_move_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_MOVE, ThemeKey.TOOL_MARK), " ", ("Move", ThemeKey.TOOL_NAME))
+    tool_name = "Move"
 
     try:
         payload = json.loads(arguments)
     except json.JSONDecodeError:
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, arguments_column)
-        return grid
+        return _render_tool_call_tree(mark=MARK_MOVE, tool_name=tool_name, details=details)
 
     source_path = payload.get("source_file_path", "")
     target_path = payload.get("target_file_path", "")
     start_line = payload.get("start_line", "")
     end_line = payload.get("end_line", "")
 
-    # Build display: source:start-end -> target
     parts = Text()
     if source_path:
         parts.append_text(render_path(source_path, ThemeKey.TOOL_PARAM_FILE_PATH))
@@ -288,26 +303,23 @@ def render_move_tool_call(arguments: str) -> RenderableType:
     if target_path:
         parts.append_text(render_path(target_path, ThemeKey.TOOL_PARAM_FILE_PATH))
 
-    grid.add_row(tool_name_column, parts)
-    return grid
+    return _render_tool_call_tree(mark=MARK_MOVE, tool_name=tool_name, details=parts)
 
 
 def render_apply_patch_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_EDIT, ThemeKey.TOOL_MARK), " ", ("Apply Patch", ThemeKey.TOOL_NAME))
+    tool_name = "Apply Patch"
 
     try:
         payload = json.loads(arguments)
     except json.JSONDecodeError:
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, arguments_column)
-        return grid
+        return _render_tool_call_tree(mark=MARK_EDIT, tool_name=tool_name, details=details)
 
     patch_content = payload.get("patch", "")
-    arguments_column = Text("", ThemeKey.TOOL_PARAM)
+    details = Text("", ThemeKey.TOOL_PARAM)
 
     if isinstance(patch_content, str):
         update_count = 0
@@ -330,15 +342,14 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
             parts.append(f"Delete File × {delete_count}" if delete_count > 1 else "Delete File")
 
         if parts:
-            arguments_column = Text(", ".join(parts), ThemeKey.TOOL_PARAM)
+            details = Text(", ".join(parts), ThemeKey.TOOL_PARAM)
     else:
-        arguments_column = Text(
-            str(patch_content)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+        details = Text(
+            str(patch_content)[:INVALID_TOOL_CALL_MAX_LENGTH],
             ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
 
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
+    return _render_tool_call_tree(mark=MARK_EDIT, tool_name=tool_name, details=details)
 
 
 def render_todo(tr: events.ToolResultEvent) -> RenderableType:
@@ -364,33 +375,34 @@ def render_todo(tr: events.ToolResultEvent) -> RenderableType:
         text.stylize(text_style)
         todo_grid.add_row(Text(mark, style=mark_style), text)
 
-    return Padding.indent(todo_grid, level=2)
+    return todo_grid
 
 
 def render_generic_tool_result(result: str, *, is_error: bool = False) -> RenderableType:
-    """Render a generic tool result as indented, truncated text."""
+    """Render a generic tool result as truncated text."""
     style = ThemeKey.ERROR if is_error else ThemeKey.TOOL_RESULT
-    return Padding.indent(truncate_display(result, base_style=style), level=2)
+    text = truncate_middle(result, base_style=style)
+    # Tool results should not reflow/wrap; use ellipsis when exceeding terminal width.
+    text.no_wrap = True
+    text.overflow = "ellipsis"
+    return text
 
 
 def _extract_mermaid_link(
     ui_extra: model.ToolResultUIExtra | None,
 ) -> model.MermaidLinkUIExtra | None:
-    if isinstance(ui_extra, model.MermaidLinkUIExtra):
-        return ui_extra
-    return None
+    return ui_extra if isinstance(ui_extra, model.MermaidLinkUIExtra) else None
 
 
 def render_mermaid_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_MERMAID, ThemeKey.TOOL_MARK), " ", ("Mermaid", ThemeKey.TOOL_NAME))
+    tool_name = "Mermaid"
     summary = Text("", ThemeKey.TOOL_PARAM)
 
     try:
         payload: dict[str, str] = json.loads(arguments)
     except json.JSONDecodeError:
         summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
     else:
@@ -401,11 +413,10 @@ def render_mermaid_tool_call(arguments: str) -> RenderableType:
         else:
             summary = Text("0 lines", ThemeKey.TOOL_PARAM)
 
-    grid.add_row(tool_name_column, summary)
-    return grid
+    return _render_tool_call_tree(mark=MARK_MERMAID, tool_name=tool_name, details=summary)
 
 
-def _truncate_url(url: str, max_length: int = 400) -> str:
+def _truncate_url(url: str, max_length: int = URL_TRUNCATE_MAX_LENGTH) -> str:
     """Truncate URL for display, preserving domain and path structure."""
     if len(url) <= max_length:
         return url
@@ -418,7 +429,7 @@ def _truncate_url(url: str, max_length: int = 400) -> str:
     if len(display_url) <= max_length:
         return display_url
     # Truncate with ellipsis
-    return display_url[: max_length - 3] + "..."
+    return display_url[: max_length - 1] + "…"
 
 
 def _render_mermaid_viewer_link(
@@ -429,7 +440,7 @@ def _render_mermaid_viewer_link(
 ) -> RenderableType:
     viewer_path = r_mermaid_viewer.build_viewer(code=link_info.code, link=link_info.link, tool_call_id=tr.tool_call_id)
     if viewer_path is None:
-        return Text(link_info.link, style=ThemeKey.TOOL_RESULT_MERMAID, overflow="fold")
+        return Text(link_info.link, style=ThemeKey.TOOL_RESULT_MERMAID, overflow="ellipsis", no_wrap=True)
 
     display_path = str(viewer_path)
 
@@ -440,7 +451,7 @@ def _render_mermaid_viewer_link(
         except ValueError:
             file_url = f"file://{viewer_path.as_posix()}"
 
-    rendered = Text.assemble(("saved in:", ThemeKey.TOOL_RESULT), " ")
+    rendered = Text.assemble(("View diagram in ", ThemeKey.TOOL_RESULT), " ")
     start = len(rendered)
     rendered.append(display_path, ThemeKey.TOOL_RESULT_MERMAID)
     end = len(rendered)
@@ -452,39 +463,34 @@ def _render_mermaid_viewer_link(
 
 
 def render_web_fetch_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_WEB_FETCH, ThemeKey.TOOL_MARK), " ", ("Fetch", ThemeKey.TOOL_NAME))
+    tool_name = "Fetch"
 
     try:
         payload: dict[str, str] = json.loads(arguments)
     except json.JSONDecodeError:
         summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, summary)
-        return grid
+        return _render_tool_call_tree(mark=MARK_WEB_FETCH, tool_name=tool_name, details=summary)
 
     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
+    return _render_tool_call_tree(mark=MARK_WEB_FETCH, tool_name=tool_name, details=summary)
 
 
 def render_web_search_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_WEB_SEARCH, ThemeKey.TOOL_MARK), " ", ("Web Search", ThemeKey.TOOL_NAME))
+    tool_name = "Web Search"
 
     try:
         payload: dict[str, Any] = json.loads(arguments)
     except json.JSONDecodeError:
         summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
         )
-        grid.add_row(tool_name_column, summary)
-        return grid
+        return _render_tool_call_tree(mark=MARK_WEB_SEARCH, tool_name=tool_name, details=summary)
 
     query = payload.get("query", "")
     max_results = payload.get("max_results")
@@ -492,19 +498,24 @@ def render_web_search_tool_call(arguments: str) -> RenderableType:
     summary = Text("", ThemeKey.TOOL_PARAM)
     if query:
         # Truncate long queries
-        display_query = query if len(query) <= 80 else query[:77] + "..."
+        display_query = (
+            query if len(query) <= QUERY_DISPLAY_TRUNCATE_LENGTH else query[: QUERY_DISPLAY_TRUNCATE_LENGTH - 1] + "…"
+        )
         summary.append(display_query, ThemeKey.TOOL_PARAM)
     else:
         summary.append("(no query)", ThemeKey.TOOL_PARAM)
 
-    if isinstance(max_results, int) and max_results != 10:
+    if isinstance(max_results, int) and max_results != WEB_SEARCH_DEFAULT_MAX_RESULTS:
         summary.append(f" (max {max_results})", ThemeKey.TOOL_TIMEOUT)
 
-    grid.add_row(tool_name_column, summary)
-    return grid
+    return _render_tool_call_tree(mark=MARK_WEB_SEARCH, tool_name=tool_name, details=summary)
 
 
-def render_mermaid_tool_result(tr: events.ToolResultEvent) -> RenderableType:
+def render_mermaid_tool_result(
+    tr: events.ToolResultEvent,
+    *,
+    session_id: str | None = None,
+) -> RenderableType:
     from klaude_code.ui.terminal import supports_osc8_hyperlinks
 
     link_info = _extract_mermaid_link(tr.ui_extra)
@@ -513,15 +524,14 @@ def render_mermaid_tool_result(tr: events.ToolResultEvent) -> RenderableType:
 
     use_osc8 = supports_osc8_hyperlinks()
     viewer = _render_mermaid_viewer_link(tr, link_info, use_osc8=use_osc8)
-    return Padding.indent(viewer, level=2)
+
+    return viewer
 
 
 def _extract_truncation(
     ui_extra: model.ToolResultUIExtra | None,
 ) -> model.TruncationUIExtra | None:
-    if isinstance(ui_extra, model.TruncationUIExtra):
-        return ui_extra
-    return None
+    return ui_extra if isinstance(ui_extra, model.TruncationUIExtra) else None
 
 
 def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
@@ -533,7 +543,9 @@ def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
         (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)
+    text.no_wrap = True
+    text.overflow = "ellipsis"
+    return text
 
 
 def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra | None:
@@ -542,10 +554,7 @@ def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra |
 
 
 def render_report_back_tool_call() -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble((MARK_DONE, ThemeKey.TOOL_MARK), " ", ("Report Back", ThemeKey.TOOL_NAME))
-    grid.add_row(tool_name_column, "")
-    return grid
+    return _render_tool_call_tree(mark=MARK_DONE, tool_name="Report Back", details=None)
 
 
 # Tool name to active form mapping (for spinner status)
@@ -655,75 +664,76 @@ def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) ->
     )
 
 
-def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai") -> RenderableType | None:
+def render_tool_result(
+    e: events.ToolResultEvent,
+    *,
+    code_theme: str = "monokai",
+    session_id: str | None = None,
+) -> RenderableType | None:
     """Unified entry point for rendering tool results.
 
     Returns a Rich Renderable or None if the tool result should not be rendered.
     """
-    from klaude_code.ui.renderers import errors as r_errors
-
     if is_sub_agent_tool(e.tool_name):
         return None
 
+    def wrap(content: RenderableType) -> TreeQuote:
+        return TreeQuote.for_tool_result(content, is_last=e.is_last_in_turn)
+
     # Handle error case
     if e.status == "error" and e.ui_extra is None:
-        error_msg = truncate_display(e.result)
-        return r_errors.render_tool_error(error_msg)
+        return wrap(render_generic_tool_result(e.result, is_error=True))
 
     # Render multiple ui blocks if present
     if isinstance(e.ui_extra, model.MultiUIExtra) and e.ui_extra.items:
         rendered: list[RenderableType] = []
         for item in e.ui_extra.items:
             if isinstance(item, model.MarkdownDocUIExtra):
-                rendered.append(Padding.indent(render_markdown_doc(item, code_theme=code_theme), level=2))
+                rendered.append(render_markdown_doc(item, code_theme=code_theme))
             elif isinstance(item, model.DiffUIExtra):
                 show_file_name = e.tool_name in (tools.APPLY_PATCH, tools.MOVE)
-                rendered.append(
-                    Padding.indent(r_diffs.render_structured_diff(item, show_file_name=show_file_name), level=2)
-                )
-        return Group(*rendered) if rendered else None
+                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:
-        return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
+        result = render_generic_tool_result(e.result, is_error=e.status == "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)
 
+    def _render_fallback() -> TreeQuote:
+        if len(e.result.strip()) == 0:
+            return wrap(render_generic_tool_result("(no content)"))
+        return wrap(render_generic_tool_result(e.result, is_error=e.status == "error"))
+
     match e.tool_name:
         case tools.READ:
             return None
         case tools.EDIT:
-            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+            return wrap(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""))
         case tools.WRITE:
             if md_ui:
-                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
-            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+                return wrap(render_markdown_doc(md_ui, code_theme=code_theme))
+            return wrap(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""))
         case tools.MOVE:
             # Same-file move returns single DiffUIExtra, cross-file returns MultiUIExtra (handled above)
             if diff_ui:
-                return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
+                return wrap(r_diffs.render_structured_diff(diff_ui, show_file_name=True))
             return None
         case tools.APPLY_PATCH:
             if md_ui:
-                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
+                return wrap(render_markdown_doc(md_ui, code_theme=code_theme))
             if diff_ui:
-                return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
-            if len(e.result.strip()) == 0:
-                return render_generic_tool_result("(no content)")
-            return render_generic_tool_result(e.result)
+                return wrap(r_diffs.render_structured_diff(diff_ui, show_file_name=True))
+            return _render_fallback()
         case tools.TODO_WRITE | tools.UPDATE_PLAN:
-            return render_todo(e)
+            return wrap(render_todo(e))
         case tools.MERMAID:
-            return render_mermaid_tool_result(e)
+            return wrap(render_mermaid_tool_result(e, session_id=session_id))
         case tools.BASH:
-            if e.result.startswith("diff --git"):
-                return r_diffs.render_diff_panel(e.result, show_file_name=True)
-            if len(e.result.strip()) == 0:
-                return render_generic_tool_result("(no content)")
-            return render_generic_tool_result(e.result)
+            return _render_fallback()
         case _:
-            if len(e.result.strip()) == 0:
-                return render_generic_tool_result("(no content)")
-            return render_generic_tool_result(e.result)
+            return _render_fallback()