klaude-code 1.2.10__py3-none-any.whl → 1.2.12__py3-none-any.whl

klaude_code/llm/responses/client.py

@@ -6,20 +6,56 @@ import httpx
 import openai
 from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai.types import responses
+from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
 
-from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
+from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
-from klaude_code.llm.usage import MetadataTracker, convert_responses_usage
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
+
 if TYPE_CHECKING:
     from openai import AsyncStream
     from openai.types.responses import ResponseStreamEvent
 
 
+def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
+    """Build OpenAI Responses API request parameters."""
+    inputs = convert_history_to_input(param.input, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    payload: ResponseCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "include": [
+            "reasoning.encrypted_content",
+        ],
+        "store": False,
+        "stream": True,
+        "temperature": param.temperature,
+        "max_output_tokens": param.max_tokens,
+        "input": inputs,
+        "instructions": param.system,
+        "tools": tools,
+        "prompt_cache_key": param.session_id or "",
+    }
+
+    if param.thinking and param.thinking.reasoning_effort:
+        payload["reasoning"] = {
+            "effort": param.thinking.reasoning_effort,
+            "summary": param.thinking.reasoning_summary,
+        }
+
+    if param.verbosity:
+        payload["text"] = {"verbosity": param.verbosity}
+
+    return payload
+
+
 async def parse_responses_stream(
     stream: "AsyncStream[ResponseStreamEvent]",
     param: llm_param.LLMCallParameter,
@@ -95,16 +131,17 @@ async def parse_responses_stream(
                     if event.response.incomplete_details is not None:
                         error_reason = event.response.incomplete_details.reason
                     if event.response.usage is not None:
-                        usage = convert_responses_usage(
-                            input_tokens=event.response.usage.input_tokens,
-                            output_tokens=event.response.usage.output_tokens,
-                            cached_tokens=event.response.usage.input_tokens_details.cached_tokens,
-                            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(
+                            model.Usage(
+                                input_tokens=event.response.usage.input_tokens,
+                                output_tokens=event.response.usage.output_tokens,
+                                cached_tokens=event.response.usage.input_tokens_details.cached_tokens,
+                                reasoning_tokens=event.response.usage.output_tokens_details.reasoning_tokens,
+                                context_size=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))
                     metadata_tracker.set_response_id(response_id)
                     yield metadata_tracker.finalize()
@@ -162,36 +199,16 @@ class ResponsesClient(LLMClientABC):
 
         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)
+        payload = build_payload(param)
 
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
         try:
-            stream = await call_with_logged_payload(
-                self.client.responses.create,
-                model=str(param.model),
-                tool_choice="auto",
-                parallel_tool_calls=True,
-                include=[
-                    "reasoning.encrypted_content",
-                ],
-                store=param.store,
-                previous_response_id=param.previous_response_id,
-                stream=True,
-                temperature=param.temperature,
-                max_output_tokens=param.max_tokens,
-                input=inputs,
-                instructions=param.system,
-                tools=tools,
-                text={
-                    "verbosity": param.verbosity,
-                },
-                prompt_cache_key=param.session_id or "",
-                reasoning={
-                    "effort": param.thinking.reasoning_effort,
-                    "summary": param.thinking.reasoning_summary,
-                }
-                if param.thinking and param.thinking.reasoning_effort
-                else None,
+            stream = await self.client.responses.create(
+                **payload,
                 extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:

klaude_code/llm/usage.py

@@ -108,55 +108,7 @@ def convert_usage(
         reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
         or 0,
         output_tokens=usage.completion_tokens,
-        context_token=usage.total_tokens,
-        context_limit=context_limit,
-        max_tokens=max_tokens,
-    )
-
-
-def convert_anthropic_usage(
-    input_tokens: int,
-    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_token is computed from input + cached + output tokens,
-    representing the actual context window usage for this turn.
-    """
-    context_token = input_tokens + cached_tokens + output_tokens
-    return model.Usage(
-        input_tokens=input_tokens,
-        output_tokens=output_tokens,
-        cached_tokens=cached_tokens,
-        context_token=context_token,
-        context_limit=context_limit,
-        max_tokens=max_tokens,
-    )
-
-
-def convert_responses_usage(
-    input_tokens: int,
-    output_tokens: int,
-    cached_tokens: int,
-    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_token is set to total_tokens from the API response,
-    representing the actual context window usage for this turn.
-    """
-    return model.Usage(
-        input_tokens=input_tokens,
-        output_tokens=output_tokens,
-        cached_tokens=cached_tokens,
-        reasoning_tokens=reasoning_tokens,
-        context_token=total_tokens,
+        context_size=usage.total_tokens,
         context_limit=context_limit,
         max_tokens=max_tokens,
     )

klaude_code/protocol/commands.py

@@ -13,6 +13,7 @@ class CommandName(str, Enum):
     EXPORT = "export"
     STATUS = "status"
     RELEASE_NOTES = "release-notes"
+    THINKING = "thinking"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

klaude_code/protocol/llm_param.py

@@ -28,7 +28,7 @@ class Thinking(BaseModel):
     """
 
     # OpenAI Reasoning Style
-    reasoning_effort: Literal["high", "medium", "low", "minimal", "none"] | None = None
+    reasoning_effort: Literal["high", "medium", "low", "minimal", "none", "xhigh"] | None = None
     reasoning_summary: Literal["auto", "concise", "detailed"] | None = None
 
     # Claude/Gemini Thinking Style
@@ -138,12 +138,4 @@ class LLMCallParameter(LLMConfigModelParameter):
     input: list[ConversationItem]
     system: str | None = None
     tools: list[ToolSchema] | None = None
-
-    stream: Literal[True] = True  # Always True
-
-    # OpenAI Responses
-    include: list[str] | None = None
-    store: bool = True
-    previous_response_id: str | None = None
-
     session_id: str | None = None

klaude_code/protocol/model.py

@@ -20,7 +20,7 @@ class Usage(BaseModel):
     output_tokens: int = 0
 
     # Context window tracking
-    context_token: int | None = None  # Peak total_tokens seen (for context usage display)
+    context_size: int | None = None  # Peak total_tokens seen (for context usage display)
     context_limit: int | None = None  # Model's context limit
     max_tokens: int | None = None  # Max output tokens for this request
 
@@ -53,12 +53,12 @@ class Usage(BaseModel):
         """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_token is None:
+        if self.context_size is None:
             return None
         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
+        return (self.context_size / effective_limit) * 100
 
 
 class TodoItem(BaseModel):
@@ -319,6 +319,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,11 +63,14 @@ 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
-    is_new_session: bool = False
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_init_agent(self)

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

@@ -403,6 +403,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
 

klaude_code/session/selector.py

@@ -10,6 +10,11 @@ from .session import Session
 
 
 def resume_select_session() -> str | None:
+    # Column widths
+    UPDATED_AT_WIDTH = 16
+    MSG_COUNT_WIDTH = 3
+    MODEL_WIDTH = 25
+    FIRST_MESSAGE_WIDTH = 50
     sessions = Session.list_sessions()
     if not sessions:
         log("No sessions found for this project.")
@@ -31,20 +36,20 @@ def resume_select_session() -> str | None:
             model_display = s.model_name or "N/A"
 
             title = [
-                ("class:d", f"{_fmt(s.updated_at):<16} "),
-                ("class:b", f"{msg_count_display:>3}  "),
+                ("class:d", f"{_fmt(s.updated_at):<{UPDATED_AT_WIDTH}} "),
+                ("class:b", f"{msg_count_display:>{MSG_COUNT_WIDTH}}  "),
                 (
                     "class:t",
-                    f"{model_display[:29] + '…' if len(model_display) > 29 else model_display:<30}  ",
+                    f"{model_display[:MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}}  ",
                 ),
                 (
                     "class:t",
-                    f"{first_user_message.strip().replace('\n', ' ↩ '):<50}",
+                    f"{first_user_message.strip().replace('\n', ' ↩ '):<{FIRST_MESSAGE_WIDTH}}",
                 ),
             ]
             choices.append(questionary.Choice(title=title, value=s.id))
         return questionary.select(
-            message=f"{' Updated at':<17} {'Msg':>3}  {'Model':<30}  {'First message':<50}",
+            message=f"{' Updated at':<{UPDATED_AT_WIDTH + 1}} {'Msg':>{MSG_COUNT_WIDTH}}  {'Model':<{MODEL_WIDTH}}  {'First message':<{FIRST_MESSAGE_WIDTH}}",
             choices=choices,
             pointer="→",
             instruction="↑↓ to move",
@@ -63,8 +68,8 @@ def resume_select_session() -> str | None:
             msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
             model_display = s.model_name or "N/A"
             print(
-                f"{i}. {_fmt(s.updated_at)}  {msg_count_display:>3} "
-                f"{model_display[:29] + '…' if len(model_display) > 29 else model_display:<30} {s.id}  {s.work_dir}"
+                f"{i}. {_fmt(s.updated_at)}  {msg_count_display:>{MSG_COUNT_WIDTH}} "
+                f"{model_display[:MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}} {s.id}  {s.work_dir}"
             )
         try:
             raw = input("Select a session number: ").strip()

klaude_code/session/session.py

@@ -108,12 +108,8 @@ class Session(BaseModel):
         return Session(id=id or uuid.uuid4().hex, work_dir=Path.cwd())
 
     @classmethod
-    def load(cls, id: str, *, skip_if_missing: bool = False) -> "Session":
+    def load(cls, id: str) -> "Session":
         """Load an existing session or create a new one if not found."""
-
-        if skip_if_missing:
-            return Session(id=id, work_dir=Path.cwd())
-
         # Load session metadata
         sessions_dir = cls._sessions_dir()
         session_candidates = sorted(

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/modes/repl/completers.py

@@ -81,9 +81,9 @@ class _SlashCommandCompleter(Completer):
         # Get available commands
         commands = get_commands()
 
-        # Filter commands that match the fragment
+        # Filter commands that match the fragment (preserve registration order)
         matched: list[tuple[str, object, str]] = []
-        for cmd_name, cmd_obj in sorted(commands.items(), key=lambda x: str(x[1].name)):
+        for cmd_name, cmd_obj in commands.items():
             if cmd_name.startswith(frag):
                 hint = " [args]" if cmd_obj.support_addition_params else ""
                 matched.append((cmd_name, cmd_obj, hint))
@@ -103,7 +103,7 @@ class _SlashCommandCompleter(Completer):
 
             # Using HTML for formatting: bold command name, normal hint, gray summary
             display_text = HTML(
-                f"<b>{cmd_name}</b>{hint}{padding}<style color='ansibrightblack'>— {cmd_obj.summary}</style>"  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+                f"<b>{cmd_name}</b>{hint}{padding}<style color='ansibrightblack'>{cmd_obj.summary}</style>"  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             )
             completion_text = f"/{cmd_name} "
             yield Completion(

klaude_code/ui/modes/repl/event_handler.py

@@ -453,14 +453,10 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         status_text = status_text.replace("\n", "")
-        return self._truncate_status_text(status_text, max_length=30)
+        return self._truncate_status_text(status_text, max_length=100)
 
     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/input_prompt_toolkit.py

@@ -6,9 +6,7 @@ from pathlib import Path
 from typing import NamedTuple, override
 
 from prompt_toolkit import PromptSession
-from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.completion import ThreadedCompleter
-from prompt_toolkit.filters import Condition
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.patch_stdout import patch_stdout
@@ -45,9 +43,6 @@ class PromptToolkitInput(InputProviderABC):
     ):  # ▌
         self._status_provider = status_provider
 
-        # Mouse is disabled by default; only enabled when input becomes multi-line.
-        self._mouse_enabled: bool = False
-
         project = str(Path.cwd()).strip("/").replace("/", "-")
         history_path = Path.home() / ".klaude" / "projects" / f"{project}" / "input_history.txt"
 
@@ -56,8 +51,6 @@ class PromptToolkitInput(InputProviderABC):
         if not history_path.exists():
             history_path.touch()
 
-        mouse_support_filter = Condition(lambda: self._mouse_enabled)
-
         # Create key bindings with injected dependencies
         kb = create_key_bindings(
             capture_clipboard_tag=capture_clipboard_tag,
@@ -75,7 +68,7 @@ class PromptToolkitInput(InputProviderABC):
             complete_while_typing=True,
             erase_when_done=True,
             bottom_toolbar=self._render_bottom_toolbar,
-            mouse_support=mouse_support_filter,
+            mouse_support=False,
             style=Style.from_dict(
                 {
                     "completion-menu": "bg:default",
@@ -90,12 +83,6 @@ class PromptToolkitInput(InputProviderABC):
             ),
         )
 
-        try:
-            self._session.default_buffer.on_text_changed += self._on_buffer_text_changed
-        except Exception:
-            # If we can't hook the buffer events for any reason, fall back to static behavior.
-            pass
-
     def _render_bottom_toolbar(self) -> FormattedText:
         """Render bottom toolbar with working directory, git branch on left, model name and context usage on right.
 
@@ -168,8 +155,6 @@ class PromptToolkitInput(InputProviderABC):
     @override
     async def iter_inputs(self) -> AsyncIterator[UserInputPayload]:
         while True:
-            # For each new prompt, start with mouse disabled so users can select history.
-            self._mouse_enabled = False
             with patch_stdout():
                 line: str = await self._session.prompt_async()
 
@@ -178,21 +163,5 @@ class PromptToolkitInput(InputProviderABC):
 
             yield UserInputPayload(text=line, images=images if images else None)
 
-    def _on_buffer_text_changed(self, buf: Buffer) -> None:
-        """Toggle mouse support based on current buffer content.
-
-        Mouse stays disabled when input is empty. It is enabled only when
-        the user has entered more than one line of text.
-        """
-        try:
-            text = buf.text
-        except Exception:
-            return
-        self._mouse_enabled = self._should_enable_mouse(text)
-
-    def _should_enable_mouse(self, text: str) -> bool:
-        """Return True when mouse support should be enabled for current input."""
-        if not text.strip():
-            return False
-        # Enable mouse only when input spans multiple lines.
-        return "\n" in text
+    # Note: Mouse support is intentionally disabled at the PromptSession
+    # level so that terminals retain their native scrollback behavior.