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

klaude_code/session/export.py

@@ -159,20 +159,35 @@ def _format_cost(cost: float, currency: str = "USD") -> str:
     return f"{symbol}{cost:.4f}"
 
 
-def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
-    # Model Name [@ Provider]
+def _render_single_metadata(
+    metadata: model.TaskMetadata,
+    *,
+    indent: int = 0,
+    show_context: bool = True,
+) -> str:
+    """Render a single TaskMetadata block as HTML.
+
+    Args:
+        metadata: The TaskMetadata to render.
+        indent: Number of spaces to indent (0 for main, 2 for sub-agents).
+        show_context: Whether to show context usage percent.
+
+    Returns:
+        HTML string for this metadata block.
+    """
     parts: list[str] = []
 
-    model_parts = [f'<span class="metadata-model">{_escape_html(item.model_name)}</span>']
-    if item.provider:
-        provider = _escape_html(item.provider.lower().replace(" ", "-"))
+    # Model Name [@ Provider]
+    model_parts = [f'<span class="metadata-model">{_escape_html(metadata.model_name)}</span>']
+    if metadata.provider:
+        provider = _escape_html(metadata.provider.lower().replace(" ", "-"))
         model_parts.append(f'<span class="metadata-provider">@{provider}</span>')
 
     parts.append("".join(model_parts))
 
     # Stats
-    if item.usage:
-        u = item.usage
+    if metadata.usage:
+        u = metadata.usage
         # Input with cost
         input_stat = f"input: {_format_token_count(u.input_tokens)}"
         if u.input_cost is not None:
@@ -194,22 +209,39 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
 
         if u.reasoning_tokens > 0:
             parts.append(f'<span class="metadata-stat">thinking: {_format_token_count(u.reasoning_tokens)}</span>')
-        if u.context_usage_percent is not None:
+        if show_context and u.context_usage_percent is not None:
             parts.append(f'<span class="metadata-stat">context: {u.context_usage_percent:.1f}%</span>')
         if u.throughput_tps is not None:
             parts.append(f'<span class="metadata-stat">tps: {u.throughput_tps:.1f}</span>')
 
-    if item.task_duration_s is not None:
-        parts.append(f'<span class="metadata-stat">time: {item.task_duration_s:.1f}s</span>')
+    if metadata.task_duration_s is not None:
+        parts.append(f'<span class="metadata-stat">time: {metadata.task_duration_s:.1f}s</span>')
 
     # Total cost
-    if item.usage is not None and item.usage.total_cost is not None:
-        parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost, item.usage.currency)}</span>')
+    if metadata.usage is not None and metadata.usage.total_cost is not None:
+        parts.append(
+            f'<span class="metadata-stat">cost: {_format_cost(metadata.usage.total_cost, metadata.usage.currency)}</span>'
+        )
 
     divider = '<span class="metadata-divider">/</span>'
     joined_html = divider.join(parts)
 
-    return f'<div class="response-metadata"><div class="metadata-line">{joined_html}</div></div>'
+    indent_style = f' style="padding-left: {indent}em;"' if indent > 0 else ""
+    return f'<div class="metadata-line"{indent_style}>{joined_html}</div>'
+
+
+def _render_metadata_item(item: model.TaskMetadataItem) -> str:
+    """Render TaskMetadataItem including main agent and sub-agents."""
+    lines: list[str] = []
+
+    # Main agent metadata
+    lines.append(_render_single_metadata(item.main, indent=0, show_context=True))
+
+    # Sub-agent metadata with indent
+    for sub in item.sub_agent_task_metadata:
+        lines.append(_render_single_metadata(sub, indent=1, show_context=False))
+
+    return f'<div class="response-metadata">{"".join(lines)}</div>'
 
 
 def _render_assistant_message(index: int, content: str, timestamp: datetime) -> str:
@@ -336,11 +368,9 @@ def _render_diff_block(diff: str) -> str:
 
 
 def _get_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if ui_extra is None:
-        return None
-    if ui_extra.type != model.ToolResultUIExtraType.DIFF_TEXT:
-        return None
-    return ui_extra.diff_text
+    if isinstance(ui_extra, model.DiffTextUIExtra):
+        return ui_extra.diff_text
+    return None
 
 
 def _get_mermaid_link_html(
@@ -355,9 +385,7 @@ def _get_mermaid_link_html(
     else:
         code = ""
 
-    if not code and (
-        ui_extra is None or ui_extra.type != model.ToolResultUIExtraType.MERMAID_LINK or not ui_extra.mermaid_link
-    ):
+    if not code and not isinstance(ui_extra, model.MermaidLinkUIExtra):
         return None
 
     # Prepare code for rendering and copy
@@ -376,11 +404,7 @@ def _get_mermaid_link_html(
             f'<button type="button" class="copy-mermaid-btn" data-code="{escaped_code}" title="Copy Mermaid Code">Copy Code</button>'
         )
 
-    link = (
-        ui_extra.mermaid_link.link
-        if (ui_extra and ui_extra.type == model.ToolResultUIExtraType.MERMAID_LINK and ui_extra.mermaid_link)
-        else None
-    )
+    link = ui_extra.link if isinstance(ui_extra, model.MermaidLinkUIExtra) else None
 
     if link:
         link_url = _escape_html(link)
@@ -544,7 +568,7 @@ def _build_messages_html(
         elif isinstance(item, model.AssistantMessageItem):
             assistant_counter += 1
             blocks.append(_render_assistant_message(assistant_counter, item.content or "", item.created_at))
-        elif isinstance(item, model.ResponseMetadataItem):
+        elif isinstance(item, model.TaskMetadataItem):
             blocks.append(_render_metadata_item(item))
         elif isinstance(item, model.DeveloperMessageItem):
             content = _escape_html(item.content or "")

klaude_code/session/session.py

@@ -5,7 +5,7 @@ from collections.abc import Iterable, Sequence
 from pathlib import Path
 from typing import ClassVar
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, PrivateAttr
 
 from klaude_code.protocol import events, model
 
@@ -19,8 +19,6 @@ class Session(BaseModel):
     file_tracker: dict[str, float] = Field(default_factory=dict)
     # Todo list for the session
     todos: list[model.TodoItem] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
-    # Messages count, redundant state for performance optimization to avoid reading entire jsonl file
-    messages_count: int = Field(default=0)
     # Model name used for this session
     # Used in list method SessionMetaBrief
     model_name: str | None = None
@@ -33,6 +31,27 @@ class Session(BaseModel):
     need_todo_empty_cooldown_counter: int = Field(exclude=True, default=0)
     need_todo_not_used_cooldown_counter: int = Field(exclude=True, default=0)
 
+    # Cached messages count (computed property)
+    _messages_count_cache: int | None = PrivateAttr(default=None)
+
+    @property
+    def messages_count(self) -> int:
+        """Count of user and assistant messages in conversation history.
+
+        This is a cached property that is invalidated when append_history is called.
+        """
+        if self._messages_count_cache is None:
+            self._messages_count_cache = sum(
+                1
+                for it in self.conversation_history
+                if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem))
+            )
+        return self._messages_count_cache
+
+    def _invalidate_messages_count_cache(self) -> None:
+        """Invalidate the cached messages count."""
+        self._messages_count_cache = None
+
     # Internal: mapping for (de)serialization of conversation items
     _TypeMap: ClassVar[dict[str, type[BaseModel]]] = {
         # Messages
@@ -50,7 +69,7 @@ class Session(BaseModel):
         "AssistantMessageDelta": model.AssistantMessageDelta,
         "StartItem": model.StartItem,
         "StreamErrorItem": model.StreamErrorItem,
-        "ResponseMetadataItem": model.ResponseMetadataItem,
+        "TaskMetadataItem": model.TaskMetadataItem,
         "InterruptItem": model.InterruptItem,
     }
 
@@ -109,7 +128,6 @@ class Session(BaseModel):
         loaded_memory = list(raw.get("loaded_memory", []))
         created_at = float(raw.get("created_at", time.time()))
         updated_at = float(raw.get("updated_at", created_at))
-        messages_count = int(raw.get("messages_count", 0))
         model_name = raw.get("model_name")
 
         sess = Session(
@@ -121,7 +139,6 @@ class Session(BaseModel):
             loaded_memory=loaded_memory,
             created_at=created_at,
             updated_at=updated_at,
-            messages_count=messages_count,
             model_name=model_name,
         )
 
@@ -154,10 +171,7 @@ class Session(BaseModel):
                     # Best-effort load; skip malformed lines
                     continue
             sess.conversation_history = history
-            # Update messages count based on loaded history (only UserMessageItem and AssistantMessageItem)
-            sess.messages_count = sum(
-                1 for it in history if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem))
-            )
+            # messages_count is now a computed property, no need to set it
 
         return sess
 
@@ -190,10 +204,8 @@ class Session(BaseModel):
     def append_history(self, items: Sequence[model.ConversationItem]):
         # Append to in-memory history
         self.conversation_history.extend(items)
-        # Update messages count (only UserMessageItem and AssistantMessageItem)
-        self.messages_count += sum(
-            1 for it in items if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem))
-        )
+        # Invalidate messages count cache
+        self._invalidate_messages_count_cache()
 
         # Incrementally persist to JSONL under messages directory
         messages_dir = self._messages_dir()
@@ -295,8 +307,8 @@ class Session(BaseModel):
                         content=ri.content,
                         session_id=self.id,
                     )
-                case model.ResponseMetadataItem() as mt:
-                    yield events.ResponseMetadataEvent(
+                case model.TaskMetadataItem() as mt:
+                    yield events.TaskMetadataEvent(
                         session_id=self.id,
                         metadata=mt,
                     )

klaude_code/session/templates/export_session.html

@@ -21,7 +21,7 @@
       rel="stylesheet"
     />
     <link
-      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;700&family=IBM+Plex+Sans:wght@400;500;700&display=swap"
+      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,400;0,500;0,700;1,400;1,500;1,700&family=IBM+Plex+Sans:ital,wght@0,400;0,500;0,700;1,400;1,500;1,700&display=swap"
       rel="stylesheet"
     />
     <style>
@@ -411,6 +411,9 @@
         font-size: var(--font-size-xs);
         color: var(--text-dim);
         border-left: 2px solid transparent;
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
       }
       .metadata-line {
         display: flex;

klaude_code/ui/modes/repl/__init__.py

@@ -22,11 +22,7 @@ def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None
     tool_calls = 0
 
     if agent is not None:
-        profile = agent.profile
-        if profile is not None:
-            model_name = profile.llm_client.model_name or ""
-        else:
-            model_name = "N/A"
+        model_name = agent.profile.llm_client.model_name or ""
 
         history = agent.session.conversation_history
         for item in history:

klaude_code/ui/modes/repl/event_handler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Awaitable, Callable
 
 from rich.text import Text
@@ -14,34 +15,130 @@ from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 from klaude_code.ui.utils.debouncer import Debouncer
 
 
+@dataclass
+class ActiveStream:
+    """Active streaming state containing buffer and markdown renderer.
+
+    This represents an active streaming session where content is being
+    accumulated in a buffer and rendered via MarkdownStream.
+    When streaming ends, this object is replaced with None.
+    """
+
+    buffer: str
+    mdstream: MarkdownStream
+
+    def append(self, content: str) -> None:
+        self.buffer += content
+
+
 class StreamState:
+    """Manages assistant message streaming state.
+
+    The streaming state is either:
+    - None: No active stream
+    - ActiveStream: Active streaming with buffer and markdown renderer
+
+    This design ensures buffer and mdstream are always in sync.
+    """
+
     def __init__(self, interval: float, flush_handler: Callable[["StreamState"], Awaitable[None]]):
-        self.buffer: str = ""
-        self.mdstream: MarkdownStream | None = None
+        self._active: ActiveStream | None = None
         self._flush_handler = flush_handler
         self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
 
     async def _debounced_flush(self) -> None:
         await self._flush_handler(self)
 
+    @property
+    def is_active(self) -> bool:
+        return self._active is not None
+
+    @property
+    def buffer(self) -> str:
+        return self._active.buffer if self._active else ""
+
+    @property
+    def mdstream(self) -> MarkdownStream | None:
+        return self._active.mdstream if self._active else None
+
+    def start(self, mdstream: MarkdownStream) -> None:
+        """Start a new streaming session."""
+        self._active = ActiveStream(buffer="", mdstream=mdstream)
+
     def append(self, content: str) -> None:
-        self.buffer += content
+        """Append content to the buffer."""
+        if self._active:
+            self._active.append(content)
+
+    def finish(self) -> None:
+        """End the current streaming session."""
+        self._active = None
+
+
+class ActivityState:
+    """Represents the current activity state for spinner display.
+
+    This is a discriminated union where the state is either:
+    - None (thinking/idle)
+    - Composing (assistant is streaming text)
+    - ToolCalls (one or more tool calls in progress)
+
+    Composing and ToolCalls are mutually exclusive - when tool calls start,
+    composing state is automatically cleared.
+    """
+
+    def __init__(self) -> None:
+        self._composing: bool = False
+        self._tool_calls: dict[str, int] = {}
+
+    @property
+    def is_composing(self) -> bool:
+        return self._composing and not self._tool_calls
+
+    @property
+    def has_tool_calls(self) -> bool:
+        return bool(self._tool_calls)
+
+    def set_composing(self, composing: bool) -> None:
+        self._composing = composing
+
+    def add_tool_call(self, tool_name: str) -> None:
+        self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
 
-    def clear(self) -> None:
-        self.buffer = ""
+    def clear_tool_calls(self) -> None:
+        self._tool_calls = {}
+
+    def reset(self) -> None:
+        self._composing = False
+        self._tool_calls = {}
+
+    def get_activity_text(self) -> Text | None:
+        """Get activity text for display. Returns None if idle/thinking."""
+        if self._tool_calls:
+            activity_text = Text()
+            first = True
+            for name, count in self._tool_calls.items():
+                if not first:
+                    activity_text.append(", ")
+                activity_text.append(name, style="bold")
+                if count > 1:
+                    activity_text.append(f" x {count}")
+                first = False
+            return activity_text
+        if self._composing:
+            return Text("Composing")
+        return None
 
 
 class SpinnerStatusState:
     """Multi-layer spinner status state management.
 
-    Layers (from low to high priority):
+    Composed of two independent layers:
     - base_status: Set by TodoChange, persistent within a turn
-    - composing: True when assistant is streaming text
-    - tool_calls: Accumulated from ToolCallStart, cleared at turn start
+    - activity: Current activity (composing or tool_calls), mutually exclusive
 
     Display logic:
-    - If tool_calls: show base + tool_calls (composing is hidden)
-    - Elif composing: show base + "Composing"
+    - If activity: show base + activity (if base exists) or activity + "..."
     - Elif base_status: show base_status
     - Else: show "Thinking …"
     """
@@ -50,14 +147,12 @@ class SpinnerStatusState:
 
     def __init__(self) -> None:
         self._base_status: str | None = None
-        self._composing: bool = False
-        self._tool_calls: dict[str, int] = {}
+        self._activity = ActivityState()
 
     def reset(self) -> None:
         """Reset all layers."""
         self._base_status = None
-        self._composing = False
-        self._tool_calls = {}
+        self._activity.reset()
 
     def set_base_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
@@ -65,37 +160,23 @@ class SpinnerStatusState:
 
     def set_composing(self, composing: bool) -> None:
         """Set composing state when assistant is streaming."""
-        self._composing = composing
+        self._activity.set_composing(composing)
 
     def add_tool_call(self, tool_name: str) -> None:
         """Add a tool call to the accumulator."""
-        self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
+        self._activity.add_tool_call(tool_name)
 
     def clear_tool_calls(self) -> None:
-        """Clear tool calls and composing state."""
-        self._tool_calls = {}
+        """Clear tool calls."""
+        self._activity.clear_tool_calls()
 
     def clear_for_new_turn(self) -> None:
-        """Clear tool calls and composing state for a new turn."""
-        self._tool_calls = {}
-        self._composing = False
+        """Clear activity state for a new turn."""
+        self._activity.reset()
 
     def get_status(self) -> Text:
         """Get current spinner status as rich Text."""
-        # Build activity text (tool_calls or composing)
-        activity_text: Text | None = None
-        if self._tool_calls:
-            activity_text = Text()
-            first = True
-            for name, count in self._tool_calls.items():
-                if not first:
-                    activity_text.append(", ")
-                activity_text.append(name, style="bold")
-                if count > 1:
-                    activity_text.append(f" × {count}")
-                first = False
-        elif self._composing:
-            activity_text = Text("Composing")
+        activity_text = self._activity.get_activity_text()
 
         if self._base_status:
             result = Text(self._base_status)
@@ -151,12 +232,14 @@ class DisplayEventHandler:
                 await self._on_tool_call(e)
             case events.ToolResultEvent() as e:
                 await self._on_tool_result(e)
-            case events.ResponseMetadataEvent() as e:
-                self._on_response_metadata(e)
+            case events.TaskMetadataEvent() as e:
+                self._on_task_metadata(e)
             case events.TodoChangeEvent() as e:
                 self._on_todo_change(e)
             case events.TurnEndEvent():
                 pass
+            case events.ResponseMetadataEvent():
+                pass  # Internal event, not displayed
             case events.TaskFinishEvent() as e:
                 await self._on_task_finish(e)
             case events.InterruptEvent() as e:
@@ -212,12 +295,12 @@ class DisplayEventHandler:
             return
         if len(event.content.strip()) == 0 and self.stage_manager.current_stage != Stage.ASSISTANT:
             return
-        first_delta = self.assistant_stream.mdstream is None
+        first_delta = not self.assistant_stream.is_active
         if first_delta:
             self.spinner_status.set_composing(True)
             self.spinner_status.clear_tool_calls()
             self._update_spinner()
-            self.assistant_stream.mdstream = MarkdownStream(
+            mdstream = MarkdownStream(
                 mdargs={"code_theme": self.renderer.themes.code_theme},
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
@@ -225,6 +308,7 @@ class DisplayEventHandler:
                 mark="➤",
                 indent=2,
             )
+            self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
         if first_delta and self.assistant_stream.mdstream is not None:
             # Stop spinner and immediately start MarkdownStream's Live
@@ -239,13 +323,14 @@ class DisplayEventHandler:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
         await self.stage_manager.transition_to(Stage.ASSISTANT)
-        if self.assistant_stream.mdstream is not None:
+        if self.assistant_stream.is_active:
             self.assistant_stream.debouncer.cancel()
-            self.assistant_stream.mdstream.update(event.content.strip(), final=True)
+            mdstream = self.assistant_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(event.content.strip(), final=True)
         else:
             self.renderer.display_assistant_message(event.content)
-        self.assistant_stream.clear()
-        self.assistant_stream.mdstream = None
+        self.assistant_stream.finish()
         self.spinner_status.set_composing(False)
         self._update_spinner()
         await self.stage_manager.transition_to(Stage.WAITING)
@@ -269,8 +354,8 @@ class DisplayEventHandler:
         await self.stage_manager.transition_to(Stage.TOOL_RESULT)
         self.renderer.display_tool_call_result(event)
 
-    def _on_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
-        self.renderer.display_response_metadata(event)
+    def _on_task_metadata(self, event: events.TaskMetadataEvent) -> None:
+        self.renderer.display_task_metadata(event)
 
     def _on_todo_change(self, event: events.TodoChangeEvent) -> None:
         active_form_status_text = self._extract_active_form_text(event)
@@ -314,11 +399,12 @@ class DisplayEventHandler:
     # ─────────────────────────────────────────────────────────────────────────────
 
     async def _finish_assistant_stream(self) -> None:
-        if self.assistant_stream.mdstream is not None:
+        if self.assistant_stream.is_active:
             self.assistant_stream.debouncer.cancel()
-            self.assistant_stream.mdstream.update(self.assistant_stream.buffer, final=True)
-            self.assistant_stream.mdstream = None
-            self.assistant_stream.clear()
+            mdstream = self.assistant_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(self.assistant_stream.buffer, final=True)
+            self.assistant_stream.finish()
 
     def _print_thinking_prefix(self) -> None:
         self.renderer.display_thinking_prefix()
@@ -328,8 +414,10 @@ class DisplayEventHandler:
         self.renderer.spinner_update(self.spinner_status.get_status())
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
-        if state.mdstream is not None:
-            state.mdstream.update(state.buffer)
+        if state.is_active:
+            mdstream = state.mdstream
+            assert mdstream is not None
+            mdstream.update(state.buffer)
 
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.notifier is None:
@@ -360,8 +448,19 @@ class DisplayEventHandler:
         status_text = ""
         for todo in todo_event.todos:
             if todo.status == "in_progress":
-                if len(todo.activeForm) > 0:
-                    status_text = todo.activeForm
+                if len(todo.active_form) > 0:
+                    status_text = todo.active_form
                 if len(todo.content) > 0:
                     status_text = todo.content
-        return status_text.replace("\n", "")
+        status_text = status_text.replace("\n", "")
+        return self._truncate_status_text(status_text, max_length=30)
+
+    def _truncate_status_text(self, text: str, max_length: int) -> str:
+        """Truncate text to max_length while preserving complete words."""
+        if len(text) <= max_length:
+            return text
+        truncated = text[:max_length]
+        last_space = truncated.rfind(" ")
+        if last_space > 0:
+            return truncated[:last_space] + "..."
+        return truncated + "..."

klaude_code/ui/modes/repl/renderer.py

@@ -184,8 +184,8 @@ class REPLRenderer:
                         self.display_tool_call(tool_call_event)
                     tool_call_dict.pop(tool_result_event.tool_call_id, None)
                     self.display_tool_call_result(tool_result_event)
-                case events.ResponseMetadataEvent() as metadata_event:
-                    self.print(r_metadata.render_response_metadata(metadata_event))
+                case events.TaskMetadataEvent() as metadata_event:
+                    self.print(r_metadata.render_task_metadata(metadata_event))
                     self.print()
                 case events.InterruptEvent():
                     self.print()
@@ -233,9 +233,9 @@ class REPLRenderer:
             self.print(renderable)
             self.print()
 
-    def display_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
+    def display_task_metadata(self, event: events.TaskMetadataEvent) -> None:
         with self.session_print_context(event.session_id):
-            self.print(r_metadata.render_response_metadata(event))
+            self.print(r_metadata.render_task_metadata(event))
             self.print()
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None: