klaude-code 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/llm/{metadata_tracker.py → usage.py}

@@ -1,16 +1,42 @@
 import time
 
-from klaude_code.protocol import model
+import openai.types
+
+from klaude_code.protocol import llm_param, model
+
+
+def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> None:
+    """Calculate and set cost fields on usage based on cost configuration.
+
+    Note: input_tokens includes cached_tokens, so we need to subtract cached_tokens
+    to get the actual non-cached input tokens for cost calculation.
+    """
+    if cost_config is None:
+        return
+
+    # Non-cached input tokens cost
+    non_cached_input = usage.input_tokens - usage.cached_tokens
+    usage.input_cost = (non_cached_input / 1_000_000) * cost_config.input
+
+    # Output tokens cost (includes reasoning tokens)
+    usage.output_cost = (usage.output_tokens / 1_000_000) * cost_config.output
+
+    # Cache read cost
+    usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * cost_config.cache_read
+
+    # Total cost
+    usage.total_cost = usage.input_cost + usage.output_cost + usage.cache_read_cost
 
 
 class MetadataTracker:
     """Tracks timing and metadata for LLM responses."""
 
-    def __init__(self) -> None:
+    def __init__(self, cost_config: llm_param.Cost | None = None) -> None:
         self._request_start_time: float = time.time()
         self._first_token_time: float | None = None
         self._last_token_time: float | None = None
         self._metadata_item = model.ResponseMetadataItem()
+        self._cost_config = cost_config
 
     @property
     def metadata_item(self) -> model.ResponseMetadataItem:
@@ -59,4 +85,25 @@ class MetadataTracker:
                 if time_duration >= 0.15:
                     self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
 
+        # Calculate cost if config is available
+        if self._metadata_item.usage:
+            calculate_cost(self._metadata_item.usage, self._cost_config)
+
         return self._metadata_item
+
+
+def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
+    """Convert OpenAI CompletionUsage to internal Usage model."""
+    total_tokens = usage.total_tokens
+    context_usage_percent = (total_tokens / context_limit) * 100 if context_limit else None
+    return model.Usage(
+        input_tokens=usage.prompt_tokens,
+        cached_tokens=(usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0) or 0,
+        reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
+        or 0,
+        output_tokens=usage.completion_tokens,
+        total_tokens=total_tokens,
+        context_usage_percent=context_usage_percent,
+        throughput_tps=None,
+        first_token_latency_ms=None,
+    )

klaude_code/protocol/llm_param.py

@@ -35,6 +35,15 @@ class Thinking(BaseModel):
     budget_tokens: int | None = None
 
 
+class Cost(BaseModel):
+    """Cost configuration per million tokens (USD)."""
+
+    input: float  # Input token price per million tokens
+    output: float  # Output token price per million tokens
+    cache_read: float = 0.0  # Cache read price per million tokens
+    cache_write: float = 0.0  # Cache write price per million tokens (ignored in calculation for now)
+
+
 class OpenRouterProviderRouting(BaseModel):
     """
     https://openrouter.ai/docs/features/provider-routing#json-schema-for-provider-preferences
@@ -99,6 +108,9 @@ class LLMConfigModelParameter(BaseModel):
     # OpenRouter Provider Routing Preferences
     provider_routing: OpenRouterProviderRouting | None = None
 
+    # Cost configuration (USD per million tokens)
+    cost: Cost | None = None
+
 
 class LLMConfigParameter(LLMConfigProviderParameter, LLMConfigModelParameter):
     """

klaude_code/protocol/model.py

@@ -1,7 +1,8 @@
+from datetime import datetime
 from enum import Enum
 from typing import Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
@@ -20,6 +21,12 @@ class Usage(BaseModel):
     throughput_tps: float | None = None
     first_token_latency_ms: float | None = None
 
+    # Cost in USD (calculated from token counts and cost config)
+    input_cost: float | None = None  # Cost for non-cached input tokens
+    output_cost: float | None = None  # Cost for output tokens (including reasoning)
+    cache_read_cost: float | None = None  # Cost for cached tokens
+    total_cost: float | None = None  # Total cost (input + output + cache_read)
+
 
 class TodoItem(BaseModel):
     content: str
@@ -113,16 +120,18 @@ When adding a new item, please also modify the following:
 
 class StartItem(BaseModel):
     response_id: str
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class InterruptItem(BaseModel):
-    pass
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class SystemMessageItem(BaseModel):
     id: str | None = None
     role: RoleType = "system"
     content: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class DeveloperMessageItem(BaseModel):
@@ -130,6 +139,7 @@ class DeveloperMessageItem(BaseModel):
     role: RoleType = "developer"
     content: str | None = None  # For LLM input
     images: list["ImageURLPart"] | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
     # Special fields for reminders UI
     memory_paths: list[str] | None = None
@@ -137,7 +147,7 @@ class DeveloperMessageItem(BaseModel):
     todo_use: bool | None = None
     at_files: list[AtPatternParseResult] | None = None
     command_output: CommandOutput | None = None
-    clipboard_images: list[str] | None = None
+    user_image_count: int | None = None
 
 
 class ImageURLPart(BaseModel):
@@ -164,6 +174,7 @@ class UserMessageItem(BaseModel):
     role: RoleType = "user"
     content: str | None = None
     images: list[ImageURLPart] | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class AssistantMessageItem(BaseModel):
@@ -171,6 +182,7 @@ class AssistantMessageItem(BaseModel):
     role: RoleType = "assistant"
     content: str | None = None
     response_id: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ReasoningTextItem(BaseModel):
@@ -178,6 +190,7 @@ class ReasoningTextItem(BaseModel):
     response_id: str | None = None
     content: str
     model: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ReasoningEncryptedItem(BaseModel):
@@ -186,6 +199,7 @@ class ReasoningEncryptedItem(BaseModel):
     encrypted_content: str  # OpenAI encrypted content or Anthropic thinking signature
     format: str | None = None
     model: str | None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ToolCallStartItem(BaseModel):
@@ -198,6 +212,7 @@ class ToolCallStartItem(BaseModel):
     response_id: str | None = None
     call_id: str
     name: str
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ToolCallItem(BaseModel):
@@ -206,6 +221,7 @@ class ToolCallItem(BaseModel):
     call_id: str
     name: str
     arguments: str
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ToolResultItem(BaseModel):
@@ -216,15 +232,18 @@ class ToolResultItem(BaseModel):
     ui_extra: ToolResultUIExtra | None = None  # Extra data for UI display, e.g. diff render
     images: list[ImageURLPart] | None = None
     side_effects: list[ToolSideEffect] | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class AssistantMessageDelta(BaseModel):
     response_id: str | None = None
     content: str
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class StreamErrorItem(BaseModel):
     error: str
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ResponseMetadataItem(BaseModel):
@@ -235,6 +254,7 @@ class ResponseMetadataItem(BaseModel):
     task_duration_s: float | None = None
     status: str | None = None
     error_reason: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
 
 
 MessageItem = (

klaude_code/protocol/op.py

@@ -5,7 +5,8 @@ This module defines the operation types and submission structure
 that the executor uses to handle different types of requests.
 """
 
-from abc import ABC, abstractmethod
+from __future__ import annotations
+
 from enum import Enum
 from typing import TYPE_CHECKING
 from uuid import uuid4
@@ -15,7 +16,7 @@ from pydantic import BaseModel, Field
 from klaude_code.protocol.model import UserInputPayload
 
 if TYPE_CHECKING:
-    from klaude_code.core.executor import ExecutorContext
+    from klaude_code.protocol.op_handler import OperationHandler
 
 
 class OperationType(Enum):
@@ -27,16 +28,15 @@ class OperationType(Enum):
     END = "end"
 
 
-class Operation(BaseModel, ABC):
+class Operation(BaseModel):
     """Base class for all operations that can be submitted to the executor."""
 
     type: OperationType
     id: str = Field(default_factory=lambda: uuid4().hex)
 
-    @abstractmethod
-    async def execute(self, context: "ExecutorContext") -> None:
-        """Execute this operation within the given executor context."""
-        pass
+    async def execute(self, handler: OperationHandler) -> None:
+        """Execute this operation using the given handler."""
+        raise NotImplementedError("Subclasses must implement execute()")
 
 
 class UserInputOperation(Operation):
@@ -46,9 +46,9 @@ class UserInputOperation(Operation):
     input: UserInputPayload
     session_id: str | None = None
 
-    async def execute(self, context: "ExecutorContext") -> None:
+    async def execute(self, handler: OperationHandler) -> None:
         """Execute user input by running it through an agent."""
-        await context.handle_user_input(self)
+        await handler.handle_user_input(self)
 
 
 class InterruptOperation(Operation):
@@ -57,9 +57,9 @@ class InterruptOperation(Operation):
     type: OperationType = OperationType.INTERRUPT
     target_session_id: str | None = None  # If None, interrupt all sessions
 
-    async def execute(self, context: "ExecutorContext") -> None:
+    async def execute(self, handler: OperationHandler) -> None:
         """Execute interrupt by cancelling active tasks."""
-        await context.handle_interrupt(self)
+        await handler.handle_interrupt(self)
 
 
 class InitAgentOperation(Operation):
@@ -68,8 +68,8 @@ class InitAgentOperation(Operation):
     type: OperationType = OperationType.INIT_AGENT
     session_id: str | None = None
 
-    async def execute(self, context: "ExecutorContext") -> None:
-        await context.handle_init_agent(self)
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_init_agent(self)
 
 
 class EndOperation(Operation):
@@ -77,7 +77,7 @@ class EndOperation(Operation):
 
     type: OperationType = OperationType.END
 
-    async def execute(self, context: "ExecutorContext") -> None:
+    async def execute(self, handler: OperationHandler) -> None:
         """Execute end operation - this is a no-op, just signals the executor to stop."""
         pass
 

klaude_code/protocol/op_handler.py

@@ -0,0 +1,28 @@
+"""
+Operation handler protocol for the executor system.
+
+This module defines the protocol that operation handlers must implement.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from klaude_code.protocol.op import InitAgentOperation, InterruptOperation, UserInputOperation
+
+
+class OperationHandler(Protocol):
+    """Protocol defining the interface for handling operations."""
+
+    async def handle_user_input(self, operation: UserInputOperation) -> None:
+        """Handle a user input operation."""
+        ...
+
+    async def handle_interrupt(self, operation: InterruptOperation) -> None:
+        """Handle an interrupt operation."""
+        ...
+
+    async def handle_init_agent(self, operation: InitAgentOperation) -> None:
+        """Handle an init agent operation."""
+        ...

klaude_code/protocol/tools.py

@@ -13,5 +13,3 @@ WEB_FETCH = "WebFetch"
 
 # SubAgentType is just a string alias now; agent types are defined via SubAgentProfile
 SubAgentType = str
-
-

klaude_code/session/export.py

@@ -11,8 +11,8 @@ from pathlib import Path
 from string import Template
 from typing import TYPE_CHECKING, Any, Final, cast
 
-from klaude_code.core.sub_agent import is_sub_agent_tool
 from klaude_code.protocol import llm_param, model
+from klaude_code.protocol.sub_agent import is_sub_agent_tool
 
 if TYPE_CHECKING:
     from klaude_code.session.session import Session
@@ -45,6 +45,10 @@ def _format_timestamp(value: float | None) -> str:
     return datetime.fromtimestamp(value).strftime("%Y-%m-%d %H:%M:%S")
 
 
+def _format_msg_timestamp(dt: datetime) -> str:
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
 def get_first_user_message(history: list[model.ConversationItem]) -> str:
     """Extract the first user message content from conversation history."""
     for item in history:
@@ -150,6 +154,10 @@ def _format_token_count(count: int) -> str:
     return f"{m}M" if rem == 0 else f"{m}M{rem}k"
 
 
+def _format_cost(cost: float) -> str:
+    return f"${cost:.4f}"
+
+
 def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
     # Line 1: Model Name [@ Provider]
     model_parts = [f'<span class="metadata-model">{_escape_html(item.model_name)}</span>']
@@ -163,10 +171,25 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
     stats_parts: list[str] = []
     if item.usage:
         u = item.usage
-        stats_parts.append(f'<span class="metadata-stat">input: {_format_token_count(u.input_tokens)}</span>')
+        # Input with cost
+        input_stat = f"input: {_format_token_count(u.input_tokens)}"
+        if u.input_cost is not None:
+            input_stat += f"({_format_cost(u.input_cost)})"
+        stats_parts.append(f'<span class="metadata-stat">{input_stat}</span>')
+
+        # Cached with cost
         if u.cached_tokens > 0:
-            stats_parts.append(f'<span class="metadata-stat">cached: {_format_token_count(u.cached_tokens)}</span>')
-        stats_parts.append(f'<span class="metadata-stat">output: {_format_token_count(u.output_tokens)}</span>')
+            cached_stat = f"cached: {_format_token_count(u.cached_tokens)}"
+            if u.cache_read_cost is not None:
+                cached_stat += f"({_format_cost(u.cache_read_cost)})"
+            stats_parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
+
+        # Output with cost
+        output_stat = f"output: {_format_token_count(u.output_tokens)}"
+        if u.output_cost is not None:
+            output_stat += f"({_format_cost(u.output_cost)})"
+        stats_parts.append(f'<span class="metadata-stat">{output_stat}</span>')
+
         if u.reasoning_tokens > 0:
             stats_parts.append(
                 f'<span class="metadata-stat">thinking: {_format_token_count(u.reasoning_tokens)}</span>'
@@ -177,7 +200,11 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
             stats_parts.append(f'<span class="metadata-stat">tps: {u.throughput_tps:.1f}</span>')
 
     if item.task_duration_s is not None:
-        stats_parts.append(f'<span class="metadata-stat">cost: {item.task_duration_s:.1f}s</span>')
+        stats_parts.append(f'<span class="metadata-stat">time: {item.task_duration_s:.1f}s</span>')
+
+    # Total cost
+    if item.usage is not None and item.usage.total_cost is not None:
+        stats_parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost)}</span>')
 
     stats_html = ""
     if stats_parts:
@@ -192,13 +219,15 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
     )
 
 
-def _render_assistant_message(index: int, content: str) -> str:
+def _render_assistant_message(index: int, content: str, timestamp: datetime) -> str:
     encoded = _escape_html(content)
+    ts_str = _format_msg_timestamp(timestamp)
     return (
         f'<div class="message-group assistant-message-group">'
         f'<div class="message-header">'
         f'<div class="role-label assistant">Assistant</div>'
         f'<div class="assistant-toolbar">'
+        f'<span class="timestamp">{ts_str}</span>'
         f'<button type="button" class="raw-toggle" aria-pressed="false" title="Toggle raw text view">Raw</button>'
         f'<button type="button" class="copy-raw-btn" title="Copy raw content">Copy</button>'
         f"</div>"
@@ -276,9 +305,9 @@ def _render_text_block(text: str) -> str:
     return (
         f'<div class="expandable-output expandable">'
         f'<div class="preview-text" style="white-space: pre-wrap; font-family: var(--font-mono);">{preview}</div>'
-        f'<div class="expand-hint expand-text">Click to expand full output ({len(lines)} lines)</div>'
+        f'<div class="expand-hint expand-text">click to expand full output ({len(lines)} lines)</div>'
         f'<div class="full-text" style="white-space: pre-wrap; font-family: var(--font-mono);">{full}</div>'
-        f'<div class="collapse-hint">Click to collapse</div>'
+        f'<div class="collapse-hint">click to collapse</div>'
         f"</div>"
     )
 
@@ -324,40 +353,74 @@ def _get_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
 def _get_mermaid_link_html(
     ui_extra: model.ToolResultUIExtra | None, tool_call: model.ToolCallItem | None = None
 ) -> str | None:
-    if ui_extra is None:
-        return None
-    if ui_extra.type != model.ToolResultUIExtraType.MERMAID_LINK:
-        return None
-    if ui_extra.mermaid_link is None or not ui_extra.mermaid_link.link:
-        return None
-    link = _escape_html(ui_extra.mermaid_link.link)
-    lines = ui_extra.mermaid_link.line_count
-
-    copy_btn = ""
     if tool_call and tool_call.name == "Mermaid":
         try:
             args = json.loads(tool_call.arguments)
-            code = args.get("code")
-            if code:
-                escaped_code = _escape_html(code)
-                copy_btn = f'<button type="button" class="copy-mermaid-btn" data-code="{escaped_code}" title="Copy Mermaid Code">Copy Code</button>'
+            code = args.get("code", "")
         except Exception:
-            pass
+            code = ""
+    else:
+        code = ""
 
-    return (
-        '<div style="display: flex; justify-content: space-between; align-items: center; font-family: var(--font-mono);">'
-        f"<span>Lines: {lines}</span>"
-        f"<div>"
-        f"{copy_btn}"
-        f'<a href="{link}" target="_blank" rel="noopener noreferrer" style="color: var(--accent); text-decoration: underline; margin-left: 8px;">View Diagram</a>'
-        f"</div>"
+    if not code and (
+        ui_extra is None or ui_extra.type != model.ToolResultUIExtraType.MERMAID_LINK or not ui_extra.mermaid_link
+    ):
+        return None
+
+    # Prepare code for rendering and copy
+    escaped_code = _escape_html(code) if code else ""
+    line_count = code.count("\n") + 1 if code else 0
+
+    # Build Toolbar
+    toolbar_items: list[str] = []
+
+    if line_count > 0:
+        toolbar_items.append(f"<span>Lines: {line_count}</span>")
+
+    buttons_html: list[str] = []
+    if code:
+        buttons_html.append(
+            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
+    )
+
+    if link:
+        link_url = _escape_html(link)
+        buttons_html.append(
+            f'<a href="{link_url}" target="_blank" rel="noopener noreferrer" style="color: var(--accent); text-decoration: underline; margin-left: 8px;">View Online</a>'
+        )
+
+    toolbar_items.append(f"<div>{''.join(buttons_html)}</div>")
+
+    toolbar_html = (
+        '<div style="display: flex; justify-content: space-between; align-items: center; font-family: var(--font-mono); margin-top: 8px; padding-top: 8px; border-top: 1px dashed var(--border);">'
+        f"{''.join(toolbar_items)}"
         "</div>"
     )
 
+    # If we have code, render the diagram
+    if code:
+        return (
+            f'<div style="background: white; padding: 16px; border-radius: 4px; margin-top: 8px; border: 1px solid var(--border);">'
+            f'<div class="mermaid">{escaped_code}</div>'
+            f"{toolbar_html}"
+            f"</div>"
+        )
+
+    # Fallback to just link/toolbar if no code available (legacy support behavior)
+    return toolbar_html
+
 
 def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultItem | None) -> str:
     args_html = None
     is_todo_list = False
+    ts_str = _format_msg_timestamp(tool_call.created_at)
+
     if tool_call.name == "TodoWrite":
         args_html = _try_render_todo_args(tool_call.arguments)
         if args_html:
@@ -379,7 +442,21 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     if is_todo_list:
         args_section = f'<div class="tool-args">{args_html}</div>'
     else:
-        open_attr = "" if _should_collapse(args_html) else " open"
+        # Always collapse Mermaid, Edit, Write tools by default
+        always_collapse_tools = {"Mermaid", "Edit", "Write"}
+        force_collapse = tool_call.name in always_collapse_tools
+
+        # Collapse Memory tool for write operations
+        if tool_call.name == "Memory":
+            try:
+                parsed_args = json.loads(tool_call.arguments)
+                if parsed_args.get("command") in {"create", "str_replace", "insert"}:
+                    force_collapse = True
+            except Exception:
+                pass
+
+        should_collapse = force_collapse or _should_collapse(args_html)
+        open_attr = "" if should_collapse else " open"
         args_section = (
             f'<details class="tool-args-collapsible"{open_attr}>'
             "<summary>Arguments</summary>"
@@ -391,7 +468,10 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
         '<div class="tool-call">',
         '<div class="tool-header">',
         f'<span class="tool-name">{_escape_html(tool_call.name)}</span>',
+        '<div class="tool-header-right">',
         f'<span class="tool-id">{_escape_html(tool_call.call_id)}</span>',
+        f'<span class="timestamp">{ts_str}</span>',
+        "</div>",
         "</div>",
         args_section,
     ]
@@ -455,22 +535,27 @@ def _build_messages_html(
     for i, item in enumerate(renderable_items):
         if isinstance(item, model.UserMessageItem):
             text = _escape_html(item.content or "")
+            ts_str = _format_msg_timestamp(item.created_at)
             blocks.append(
                 f'<div class="message-group">'
-                f'<div class="role-label user">User</div>'
+                f'<div class="role-label user">'
+                f"User"
+                f'<span class="timestamp">{ts_str}</span>'
+                f"</div>"
                 f'<div class="message-content user" style="white-space: pre-wrap;">{text}</div>'
                 f"</div>"
             )
         elif isinstance(item, model.ReasoningTextItem):
             text = _escape_html(item.content.strip())
-            blocks.append(f'<div class="thinking-block">{text.replace(chr(10), "<br>")}</div>')
+            blocks.append(f'<div class="thinking-block markdown-body markdown-content" data-raw="{text}"></div>')
         elif isinstance(item, model.AssistantMessageItem):
             assistant_counter += 1
-            blocks.append(_render_assistant_message(assistant_counter, item.content or ""))
+            blocks.append(_render_assistant_message(assistant_counter, item.content or "", item.created_at))
         elif isinstance(item, model.ResponseMetadataItem):
             blocks.append(_render_metadata_item(item))
         elif isinstance(item, model.DeveloperMessageItem):
             content = _escape_html(item.content or "")
+            ts_str = _format_msg_timestamp(item.created_at)
 
             next_item = renderable_items[i + 1] if i + 1 < len(renderable_items) else None
             extra_class = ""
@@ -479,10 +564,14 @@ def _build_messages_html(
 
             blocks.append(
                 f'<details class="developer-message{extra_class}">'
-                f"<summary>Developer</summary>"
+                f"<summary>"
+                f"Developer"
+                f'<span class="timestamp">{ts_str}</span>'
+                f"</summary>"
                 f'<div class="details-content" style="white-space: pre-wrap;">{content}</div>'
                 f"</details>"
             )
+
         elif isinstance(item, model.ToolCallItem):
             result = tool_results.get(item.call_id)
             blocks.append(_format_tool_call(item, result))

klaude_code/session/session.py

@@ -204,7 +204,7 @@ class Session(BaseModel):
             for it in items:
                 # Serialize with explicit type tag for reliable load
                 t = it.__class__.__name__
-                data = it.model_dump()
+                data = it.model_dump(mode="json")
                 f.write(json.dumps({"type": t, "data": data}, ensure_ascii=False))
                 f.write("\n")
         # Refresh metadata timestamp after history change