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

klaude_code/llm/anthropic/client.py

@@ -46,7 +46,7 @@ class AnthropicClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         messages = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
@@ -179,6 +179,7 @@ class AnthropicClient(LLMClientABC):
                             output_tokens=output_tokens,
                             cached_tokens=cached_tokens,
                             context_limit=param.context_limit,
+                            max_tokens=param.max_tokens,
                         )
                         metadata_tracker.set_usage(usage)
                         metadata_tracker.set_model_name(str(param.model))

klaude_code/llm/client.py

@@ -19,7 +19,7 @@ class LLMClientABC(ABC):
     @abstractmethod
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         raise NotImplementedError
-        yield cast(model.ConversationItem, None)  # pyright: ignore[reportUnreachable]
+        yield cast(model.ConversationItem, None)
 
     def get_llm_config(self) -> llm_param.LLMConfigParameter:
         return self._config
@@ -42,7 +42,7 @@ def call_with_logged_payload(func: Callable[P, R], *args: P.args, **kwargs: P.kw
 
     payload = {k: v for k, v in kwargs.items() if v is not None}
     log_debug(
-        json.dumps(payload, ensure_ascii=False, default=str, sort_keys=True),
+        json.dumps(payload, ensure_ascii=False, default=str),
         style="yellow",
         debug_type=DebugType.LLM_PAYLOAD,
     )

klaude_code/llm/codex/client.py

@@ -84,7 +84,7 @@ class CodexClient(LLMClientABC):
         # Codex API requires store=False
         param.store = False
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)

klaude_code/llm/openai_compatible/client.py

@@ -47,7 +47,7 @@ class OpenAICompatibleClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         extra_body = {}
         extra_headers = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
@@ -88,7 +88,7 @@ class OpenAICompatibleClient(LLMClientABC):
                 if (
                     event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison] gcp gemini will return None usage field
                 ):
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
+                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit, param.max_tokens))
                 if event.model:
                     metadata_tracker.set_model_name(event.model)
                 if provider := getattr(event, "provider", None):
@@ -104,6 +104,7 @@ class OpenAICompatibleClient(LLMClientABC):
                         convert_usage(
                             openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
                             param.context_limit,
+                            param.max_tokens,
                         )
                     )
 

klaude_code/llm/openrouter/client.py

@@ -38,7 +38,7 @@ class OpenRouterClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         extra_body: dict[str, object] = {
             "usage": {"include": True}  # To get the cache tokens at the end of the response
@@ -73,7 +73,7 @@ class OpenRouterClient(LLMClientABC):
             max_tokens=param.max_tokens,
             tools=tools,
             verbosity=param.verbosity,
-            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
+            extra_body=extra_body,
             extra_headers=extra_headers,  # pyright: ignore[reportUnknownArgumentType]
         )
 
@@ -100,7 +100,7 @@ class OpenRouterClient(LLMClientABC):
                 if (
                     event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison]
                 ):  # gcp gemini will return None usage field
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
+                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit, param.max_tokens))
                 if event.model:
                     metadata_tracker.set_model_name(event.model)
                 if provider := getattr(event, "provider", None):

klaude_code/llm/registry.py

@@ -1,22 +1,48 @@
-from typing import Callable, TypeVar
+from typing import TYPE_CHECKING, Callable, TypeVar
 
-from klaude_code.llm.client import LLMClientABC
 from klaude_code.protocol import llm_param
 
-_REGISTRY: dict[llm_param.LLMClientProtocol, type[LLMClientABC]] = {}
+if TYPE_CHECKING:
+    from klaude_code.llm.client import LLMClientABC
 
-T = TypeVar("T", bound=LLMClientABC)
+_T = TypeVar("_T", bound=type["LLMClientABC"])
 
+# Track which protocols have been loaded
+_loaded_protocols: set[llm_param.LLMClientProtocol] = set()
+_REGISTRY: dict[llm_param.LLMClientProtocol, type["LLMClientABC"]] = {}
 
-def register(name: llm_param.LLMClientProtocol) -> Callable[[type[T]], type[T]]:
-    def _decorator(cls: type[T]) -> type[T]:
+
+def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
+    """Load the module for a specific protocol on demand."""
+    if protocol in _loaded_protocols:
+        return
+    _loaded_protocols.add(protocol)
+
+    # Import only the needed module to trigger @register decorator
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        from . import anthropic as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.CODEX:
+        from . import codex as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.OPENAI:
+        from . import openai_compatible as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        from . import openrouter as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.RESPONSES:
+        from . import responses as _  # noqa: F401
+
+
+def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:
+    """Decorator to register an LLM client class for a protocol."""
+
+    def _decorator(cls: _T) -> _T:
         _REGISTRY[name] = cls
         return cls
 
     return _decorator
 
 
-def create_llm_client(config: llm_param.LLMConfigParameter) -> LLMClientABC:
+def create_llm_client(config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+    _load_protocol(config.protocol)
     if config.protocol not in _REGISTRY:
         raise ValueError(f"Unknown LLMClient protocol: {config.protocol}")
     return _REGISTRY[config.protocol].create(config)

klaude_code/llm/responses/client.py

@@ -102,6 +102,7 @@ async def parse_responses_stream(
                             reasoning_tokens=event.response.usage.output_tokens_details.reasoning_tokens,
                             total_tokens=event.response.usage.total_tokens,
                             context_limit=param.context_limit,
+                            max_tokens=param.max_tokens,
                         )
                         metadata_tracker.set_usage(usage)
                     metadata_tracker.set_model_name(str(param.model))
@@ -159,7 +160,7 @@ class ResponsesClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)

klaude_code/llm/responses/input.py

@@ -34,7 +34,7 @@ def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInp
         "call_id": tool.call_id,
         "output": content_parts,
     }
-    return item  # type: ignore[return-value]
+    return item
 
 
 def convert_history_to_input(

klaude_code/llm/usage.py

@@ -92,10 +92,14 @@ class MetadataTracker:
         return self._metadata_item
 
 
-def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
+def convert_usage(
+    usage: openai.types.CompletionUsage,
+    context_limit: int | None = None,
+    max_tokens: int | None = None,
+) -> model.Usage:
     """Convert OpenAI CompletionUsage to internal Usage model.
 
-    context_window_size is set to total_tokens from the API response,
+    context_token is set to total_tokens from the API response,
     representing the actual context window usage for this turn.
     """
     return model.Usage(
@@ -104,8 +108,9 @@ def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None
         reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
         or 0,
         output_tokens=usage.completion_tokens,
-        context_window_size=usage.total_tokens,
+        context_token=usage.total_tokens,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )
 
 
@@ -114,19 +119,21 @@ def convert_anthropic_usage(
     output_tokens: int,
     cached_tokens: int,
     context_limit: int | None = None,
+    max_tokens: int | None = None,
 ) -> model.Usage:
     """Convert Anthropic usage data to internal Usage model.
 
-    context_window_size is computed from input + cached + output tokens,
+    context_token is computed from input + cached + output tokens,
     representing the actual context window usage for this turn.
     """
-    context_window_size = input_tokens + cached_tokens + output_tokens
+    context_token = input_tokens + cached_tokens + output_tokens
     return model.Usage(
         input_tokens=input_tokens,
         output_tokens=output_tokens,
         cached_tokens=cached_tokens,
-        context_window_size=context_window_size,
+        context_token=context_token,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )
 
 
@@ -137,10 +144,11 @@ def convert_responses_usage(
     reasoning_tokens: int,
     total_tokens: int,
     context_limit: int | None = None,
+    max_tokens: int | None = None,
 ) -> model.Usage:
     """Convert OpenAI Responses API usage data to internal Usage model.
 
-    context_window_size is set to total_tokens from the API response,
+    context_token is set to total_tokens from the API response,
     representing the actual context window usage for this turn.
     """
     return model.Usage(
@@ -148,6 +156,7 @@ def convert_responses_usage(
         output_tokens=output_tokens,
         cached_tokens=cached_tokens,
         reasoning_tokens=reasoning_tokens,
-        context_window_size=total_tokens,
+        context_token=total_tokens,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )

klaude_code/protocol/model.py

@@ -4,6 +4,7 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
+from klaude_code import const
 from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
 
@@ -19,8 +20,11 @@ class Usage(BaseModel):
     output_tokens: int = 0
 
     # Context window tracking
-    context_window_size: int | None = None  # Peak total_tokens seen (for context usage display)
+    context_token: int | None = None  # Peak total_tokens seen (for context usage display)
+    context_delta: int | None = None  # Context growth since last task (for cache ratio calculation)
+    last_turn_output_token: int | None = None  # Context growth since last task (for cache ratio calculation)
     context_limit: int | None = None  # Model's context limit
+    max_tokens: int | None = None  # Max output tokens for this request
 
     throughput_tps: float | None = None
     first_token_latency_ms: float | None = None
@@ -31,13 +35,13 @@ class Usage(BaseModel):
     cache_read_cost: float | None = None  # Cost for cached tokens
     currency: str = "USD"  # Currency for cost display (USD or CNY)
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def total_tokens(self) -> int:
         """Total tokens computed from input + output tokens."""
         return self.input_tokens + self.output_tokens
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def total_cost(self) -> float | None:
         """Total cost computed from input + output + cache_read costs."""
@@ -45,15 +49,18 @@ class Usage(BaseModel):
         non_none = [c for c in costs if c is not None]
         return sum(non_none) if non_none else None
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def context_usage_percent(self) -> float | None:
-        """Context usage percentage computed from context_window_size / context_limit."""
+        """Context usage percentage computed from context_token / (context_limit - max_tokens)."""
         if self.context_limit is None or self.context_limit <= 0:
             return None
-        if self.context_window_size is None:
+        if self.context_token is None:
             return None
-        return (self.context_window_size / self.context_limit) * 100
+        effective_limit = self.context_limit - (self.max_tokens or const.DEFAULT_MAX_TOKENS)
+        if effective_limit <= 0:
+            return None
+        return (self.context_token / effective_limit) * 100
 
 
 class TodoItem(BaseModel):
@@ -314,6 +321,7 @@ class TaskMetadata(BaseModel):
     model_name: str = ""
     provider: str | None = None
     task_duration_s: float | None = None
+    turn_count: int = 0
 
     @staticmethod
     def aggregate_by_model(metadata_list: list["TaskMetadata"]) -> list["TaskMetadata"]:

klaude_code/protocol/op.py

@@ -63,7 +63,11 @@ class InterruptOperation(Operation):
 
 
 class InitAgentOperation(Operation):
-    """Operation for initializing an agent and replaying history if any."""
+    """Operation for initializing an agent and replaying history if any.
+
+    If session_id is None, a new session is created with an auto-generated ID.
+    If session_id is provided, attempts to load existing session or creates new one.
+    """
 
     type: OperationType = OperationType.INIT_AGENT
     session_id: str | None = None

klaude_code/protocol/sub_agent.py

@@ -290,6 +290,7 @@ register_sub_agent(
         tool_set=(tools.BASH, tools.READ),
         prompt_builder=_explore_prompt_builder,
         active_form="Exploring",
+        target_model_filter=lambda model: ("haiku" not in model) and ("kimi" not in model) and ("grok" not in model),
     )
 )
 

klaude_code/session/export.py

@@ -194,11 +194,18 @@ def _render_single_metadata(
             input_stat += f"({_format_cost(u.input_cost, u.currency)})"
         parts.append(f'<span class="metadata-stat">{input_stat}</span>')
 
-        # Cached with cost
+        # Cached with cost and cache ratio
         if u.cached_tokens > 0:
             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, u.currency)})"
+            # Cache ratio: (cached + context_delta - last_turn_output) / input tokens
+            # Shows how much of the input was cached (not new context growth)
+            if u.input_tokens > 0:
+                context_delta = u.context_delta or 0
+                last_turn_output_token = u.last_turn_output_token or 0
+                cache_ratio = (u.cached_tokens + context_delta - last_turn_output_token) / u.input_tokens * 100
+                cached_stat += f"[{cache_ratio:.0f}%]"
             parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
 
         # Output with cost
@@ -294,7 +301,7 @@ def _try_render_todo_args(arguments: str) -> str | None:
             return None
 
         return f'<div class="todo-list">{"".join(items_html)}</div>'
-    except Exception:
+    except (json.JSONDecodeError, KeyError, TypeError):
         return None
 
 
@@ -380,7 +387,7 @@ def _get_mermaid_link_html(
         try:
             args = json.loads(tool_call.arguments)
             code = args.get("code", "")
-        except Exception:
+        except (json.JSONDecodeError, TypeError):
             code = ""
     else:
         code = ""
@@ -403,6 +410,9 @@ def _get_mermaid_link_html(
         buttons_html.append(
             f'<button type="button" class="copy-mermaid-btn" data-code="{escaped_code}" title="Copy Mermaid Code">Copy Code</button>'
         )
+        buttons_html.append(
+            '<button type="button" class="fullscreen-mermaid-btn" title="View Fullscreen">Fullscreen</button>'
+        )
 
     link = ui_extra.link if isinstance(ui_extra, model.MermaidLinkUIExtra) else None
 
@@ -447,7 +457,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
         try:
             parsed = json.loads(tool_call.arguments)
             args_text = json.dumps(parsed, ensure_ascii=False, indent=2)
-        except Exception:
+        except (json.JSONDecodeError, TypeError):
             args_text = tool_call.arguments
 
         args_html = _escape_html(args_text or "")
@@ -469,7 +479,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
                 parsed_args = json.loads(tool_call.arguments)
                 if parsed_args.get("command") in {"create", "str_replace", "insert"}:
                     force_collapse = True
-            except Exception:
+            except (json.JSONDecodeError, TypeError):
                 pass
 
         should_collapse = force_collapse or _should_collapse(args_html)
@@ -506,7 +516,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
                     diff_text = "\n".join(f"+{line}" for line in new_string.splitlines())
-            except Exception:
+            except (json.JSONDecodeError, TypeError):
                 pass
 
         items_to_render: list[str] = []

klaude_code/session/session.py

@@ -102,8 +102,14 @@ class Session(BaseModel):
         prefix = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime(self.created_at))
         return self._messages_dir() / f"{prefix}-{self.id}.jsonl"
 
+    @classmethod
+    def create(cls, id: str | None = None) -> "Session":
+        """Create a new session without checking for existing files."""
+        return Session(id=id or uuid.uuid4().hex, work_dir=Path.cwd())
+
     @classmethod
     def load(cls, id: str) -> "Session":
+        """Load an existing session or create a new one if not found."""
         # Load session metadata
         sessions_dir = cls._sessions_dir()
         session_candidates = sorted(
@@ -167,7 +173,7 @@ class Session(BaseModel):
                     item = cls_type(**data)
                     # pyright: ignore[reportAssignmentType]
                     history.append(item)  # type: ignore[arg-type]
-                except Exception:
+                except (json.JSONDecodeError, KeyError, TypeError):
                     # Best-effort load; skip malformed lines
                     continue
             sess.conversation_history = history
@@ -242,7 +248,7 @@ class Session(BaseModel):
                 if ts > latest_ts:
                     latest_ts = ts
                     latest_id = sid
-            except Exception:
+            except (json.JSONDecodeError, KeyError, TypeError, OSError):
                 continue
         return latest_id
 
@@ -395,7 +401,7 @@ class Session(BaseModel):
                                         text_parts.append(text)
                             return " ".join(text_parts) if text_parts else None
                         return None
-            except Exception:
+            except (json.JSONDecodeError, KeyError, TypeError, OSError):
                 return None
             return None
 
@@ -403,7 +409,7 @@ class Session(BaseModel):
         for p in sessions_dir.glob("*.json"):
             try:
                 data = json.loads(p.read_text())
-            except Exception:
+            except (json.JSONDecodeError, OSError):
                 # Skip unreadable files
                 continue
             # Filter out sub-agent sessions

klaude_code/session/templates/export_session.html

@@ -338,6 +338,57 @@
         border-color: var(--accent);
       }
 
+      .mermaid-modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100vw;
+        height: 100vh;
+        background: rgba(255, 255, 255, 0.98);
+        z-index: 1000;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        opacity: 0;
+        pointer-events: none;
+        transition: opacity 0.2s;
+      }
+      .mermaid-modal.active {
+        opacity: 1;
+        pointer-events: auto;
+      }
+      .mermaid-modal-content {
+        width: 95%;
+        height: 90%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        overflow: auto;
+      }
+      .mermaid-modal-content svg {
+        width: auto !important;
+        height: auto !important;
+        max-width: 100%;
+        max-height: 100%;
+      }
+      .mermaid-modal-close {
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        background: transparent;
+        border: none;
+        font-size: 32px;
+        cursor: pointer;
+        color: var(--text-dim);
+        z-index: 1001;
+        line-height: 1;
+        padding: 8px;
+      }
+      .mermaid-modal-close:hover {
+        color: var(--text);
+      }
+
       .copy-mermaid-btn {
         border: 1px solid var(--border);
         background: transparent;
@@ -356,6 +407,25 @@
         border-color: var(--accent);
       }
 
+      .fullscreen-mermaid-btn {
+        margin-left: 8px;
+        border: 1px solid var(--border);
+        background: transparent;
+        color: var(--text-dim);
+        font-family: var(--font-mono);
+        font-size: var(--font-size-xs);
+        text-transform: uppercase;
+        padding: 2px 10px;
+        border-radius: 999px;
+        cursor: pointer;
+        transition: color 0.2s, border-color 0.2s, background 0.2s;
+        font-weight: var(--font-weight-bold);
+      }
+      .fullscreen-mermaid-btn:hover {
+        color: var(--text);
+        border-color: var(--accent);
+      }
+
       .assistant-rendered {
         width: 100%;
       }
@@ -1065,6 +1135,13 @@
       </svg>
     </div>
 
+    <div id="mermaid-modal" class="mermaid-modal">
+      <button class="mermaid-modal-close" id="mermaid-modal-close">
+        &times;
+      </button>
+      <div class="mermaid-modal-content" id="mermaid-modal-content"></div>
+    </div>
+
     <link
       rel="stylesheet"
       href="https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11.9.0/build/styles/github.min.css"
@@ -1280,6 +1357,84 @@
         });
       });
 
+      // Mermaid Fullscreen Logic
+      const modal = document.getElementById("mermaid-modal");
+      const modalContent = document.getElementById("mermaid-modal-content");
+      const modalClose = document.getElementById("mermaid-modal-close");
+
+      if (modal && modalContent && modalClose) {
+        const closeModal = () => {
+          modal.classList.remove("active");
+          modalContent.innerHTML = "";
+        };
+
+        modalClose.addEventListener("click", closeModal);
+
+        modal.addEventListener("click", (e) => {
+          if (e.target === modal) {
+            closeModal();
+          }
+        });
+
+        // Handle Escape key
+        document.addEventListener("keydown", (e) => {
+          if (e.key === "Escape" && modal.classList.contains("active")) {
+            closeModal();
+          }
+        });
+
+        document.querySelectorAll(".fullscreen-mermaid-btn").forEach((btn) => {
+          btn.addEventListener("click", (e) => {
+            // The structure is:
+            // wrapper > mermaid > svg
+            // wrapper > toolbar > buttons > btn
+
+            // We need to find the mermaid div that is a sibling of the toolbar
+
+            // Traverse up to the wrapper
+            let wrapper = btn.closest("div[style*='background: white']");
+
+            if (!wrapper) {
+              // Fallback: try to find by traversing up and looking for .mermaid
+              let p = btn.parentElement;
+              while (p) {
+                if (p.querySelector(".mermaid")) {
+                  wrapper = p;
+                  break;
+                }
+                p = p.parentElement;
+                if (p === document.body) break;
+              }
+            }
+
+            if (wrapper) {
+              const mermaidDiv = wrapper.querySelector(".mermaid");
+              if (mermaidDiv) {
+                const svg = mermaidDiv.querySelector("svg");
+
+                if (svg) {
+                  // Clone the SVG to put in modal
+                  // We treat the SVG as the source
+                  const clone = svg.cloneNode(true);
+                  // Remove fixed sizes to let it scale in flex container
+                  clone.removeAttribute("height");
+                  clone.removeAttribute("width");
+                  clone.style.maxWidth = "100%";
+                  clone.style.maxHeight = "100%";
+
+                  modalContent.appendChild(clone);
+                  modal.classList.add("active");
+                } else if (mermaidDiv.textContent.trim()) {
+                  // Fallback if not rendered yet (should not happen on export usually)
+                  modalContent.textContent = "Diagram not rendered yet.";
+                  modal.classList.add("active");
+                }
+              }
+            }
+          });
+        });
+      }
+
       // Scroll to bottom button
       const scrollBtn = document.getElementById("scroll-btn");
 

klaude_code/ui/core/input.py

@@ -68,4 +68,4 @@ class InputProviderABC(ABC):
             UserInputPayload with text and optional images.
         """
         raise NotImplementedError
-        yield UserInputPayload(text="")  # pyright: ignore[reportUnreachable]
+        yield UserInputPayload(text="")