klaude-code 1.2.24__py3-none-any.whl → 1.2.26__py3-none-any.whl

klaude_code/cli/runtime.py

@@ -265,7 +265,23 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
         )
 
     # Set up input provider for interactive mode
-    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(status_provider=_status_provider)
+    def _stop_rich_bottom_ui() -> None:
+        display = components.display
+        if isinstance(display, ui.REPLDisplay):
+            display.renderer.spinner_stop()
+            display.renderer.stop_bottom_live()
+        elif (
+            isinstance(display, ui.DebugEventDisplay)
+            and display.wrapped_display
+            and isinstance(display.wrapped_display, ui.REPLDisplay)
+        ):
+            display.wrapped_display.renderer.spinner_stop()
+            display.wrapped_display.renderer.stop_bottom_live()
+
+    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(
+        status_provider=_status_provider,
+        pre_prompt=_stop_rich_bottom_ui,
+    )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---
     def _show_toast_once() -> None:

klaude_code/command/thinking_cmd.py

@@ -56,6 +56,14 @@ def _is_gemini_flash_model(model_name: str | None) -> bool:
     return "gemini-3-flash" in model_name.lower()
 
 
+def should_auto_trigger_thinking(model_name: str | None) -> bool:
+    """Check if model should auto-trigger thinking selection on switch."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_lower
+
+
 def _get_levels_for_responses(model_name: str | None) -> list[str]:
     """Get thinking levels for responses protocol."""
     if _is_codex_max_model(model_name):
@@ -69,7 +77,7 @@ def _get_levels_for_responses(model_name: str | None) -> list[str]:
     return RESPONSES_LEVELS
 
 
-def _format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
+def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
     """Format the current thinking configuration for display."""
     thinking = config.thinking
     if not thinking:
@@ -164,6 +172,31 @@ def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
         return None
 
 
+async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking configuration based on the LLM protocol.
+
+    Returns the selected Thinking config, or None if user cancelled.
+    """
+    protocol = config.protocol
+    model_name = config.model
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if _is_openrouter_model_with_reasoning_effort(model_name):
+            return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    return None
+
+
 class ThinkingCommand(CommandABC):
     """Configure model thinking/reasoning level."""
 
@@ -185,40 +218,16 @@ class ThinkingCommand(CommandABC):
             return self._no_change_result(agent, "No profile configured")
 
         config = agent.profile.llm_client.get_llm_config()
-        protocol = config.protocol
-        model_name = config.model
-
-        current = _format_current_thinking(config)
-
-        # Select new thinking configuration based on protocol
-        new_thinking: llm_param.Thinking | None = None
-
-        if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-            new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-
-        elif protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-            if _is_openrouter_model_with_reasoning_effort(model_name):
-                new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-            else:
-                new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENAI:
-            # openai_compatible uses anthropic style
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        else:
-            return self._no_change_result(agent, f"Unsupported protocol: {protocol}")
+        current = format_current_thinking(config)
 
+        new_thinking = await select_thinking_for_protocol(config)
         if new_thinking is None:
             return self._no_change_result(agent, "(no change)")
 
         # Apply the new thinking configuration
         config.thinking = new_thinking
         agent.session.model_thinking = new_thinking
-        new_status = _format_current_thinking(config)
+        new_status = format_current_thinking(config)
 
         return CommandResult(
             events=[

klaude_code/const.py

@@ -97,7 +97,11 @@ SUB_AGENT_RESULT_MAX_LINES = 50
 
 
 # UI refresh rate (frames per second) for debounced content streaming
-UI_REFRESH_RATE_FPS = 20
+UI_REFRESH_RATE_FPS = 10
+
+# Enable live area for streaming markdown (shows incomplete blocks being typed)
+# When False, only completed markdown blocks are displayed (more stable, less flicker)
+MARKDOWN_STREAM_LIVE_REPAINT_ENABLED = False
 
 # Number of lines to keep visible at bottom of markdown streaming window
 MARKDOWN_STREAM_LIVE_WINDOW = 6
@@ -117,16 +121,14 @@ STATUS_DEFAULT_TEXT = "Thinking …"
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10
-# Duration in seconds for one full shimmer sweep across the text
-STATUS_SHIMMER_SWEEP_SECONDS = 2
 # Half-width of the shimmer band in characters
 STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0
 # Scale factor applied to shimmer intensity when blending colors
 STATUS_SHIMMER_ALPHA_SCALE = 0.7
 
-# Spinner breathing animation
-# Duration in seconds for one full breathe-in + breathe-out cycle
-# Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
+# Spinner breathing and shimmer animation period
+# Duration in seconds for one full breathe-in + breathe-out cycle (breathing)
+# and one full shimmer sweep across the text (shimmer)
 SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 

klaude_code/core/executor.py

@@ -14,6 +14,11 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from klaude_code.command import dispatch_command
+from klaude_code.command.thinking_cmd import (
+    format_current_thinking,
+    select_thinking_for_protocol,
+    should_auto_trigger_thinking,
+)
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
@@ -235,17 +240,55 @@ class ExecutorContext:
         agent.session.model_thinking = llm_config.thinking
 
         developer_item = model.DeveloperMessageItem(
-            content=f"switched to model: {operation.model_name}",
+            content=f"Switched to: {llm_config.model}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
         )
         agent.session.append_history([developer_item])
 
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
         if self._on_model_change is not None:
             self._on_model_change(llm_client.model_name)
 
+        if should_auto_trigger_thinking(llm_config.model):
+            thinking_op = op.ChangeThinkingOperation(session_id=operation.session_id)
+            await thinking_op.execute(handler=self)
+            # WelcomeEvent is already handled by the thinking change
+        else:
+            await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
+
+    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation by prompting user to select thinking level."""
+        agent = await self._ensure_agent(operation.session_id)
+        if not agent.profile:
+            return
+
+        config = agent.profile.llm_client.get_llm_config()
+        current = format_current_thinking(config)
+
+        new_thinking = await select_thinking_for_protocol(config)
+
+        if new_thinking is None:
+            developer_item = model.DeveloperMessageItem(
+                content="(thinking unchanged)",
+                command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+            )
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+            return
+
+        config.thinking = new_thinking
+        agent.session.model_thinking = new_thinking
+        new_status = format_current_thinking(config)
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"Thinking changed: {current} -> {new_status}",
+            command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+        )
+        agent.session.append_history([developer_item])
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
         new_session = Session.create(work_dir=agent.session.work_dir)

klaude_code/core/tool/file/apply_patch_tool.py

@@ -20,7 +20,7 @@ class ApplyPatchHandler:
     @classmethod
     async def handle_apply_patch(cls, patch_text: str) -> model.ToolResultItem:
         try:
-            output, diff_ui = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
+            output, ui_extra = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
         except apply_patch_module.DiffError as error:
             return model.ToolResultItem(status="error", output=str(error))
         except Exception as error:  # pragma: no cover  # unexpected errors bubbled to tool result
@@ -28,11 +28,11 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=diff_ui,
+            ui_extra=ui_extra,
         )
 
     @staticmethod
-    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.DiffUIExtra]:
+    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.ToolResultUIExtra]:
         ap = apply_patch_module
         normalized_start = patch_text.lstrip()
         if not normalized_start.startswith("*** Begin Patch"):
@@ -69,6 +69,16 @@ class ApplyPatchHandler:
         commit = ap.patch_to_commit(patch, orig)
         diff_ui = ApplyPatchHandler._commit_to_structured_diff(commit)
 
+        md_items: list[model.MarkdownDocUIExtra] = []
+        for change_path, change in commit.changes.items():
+            if change.type == apply_patch_module.ActionType.ADD and change_path.endswith(".md"):
+                md_items.append(
+                    model.MarkdownDocUIExtra(
+                        file_path=resolve_path(change_path),
+                        content=change.new_content or "",
+                    )
+                )
+
         def write_fn(path: str, content: str) -> None:
             resolved = resolve_path(path)
             if os.path.isdir(resolved):
@@ -102,6 +112,16 @@ class ApplyPatchHandler:
                     file_tracker.pop(resolved, None)
 
         ap.apply_commit(commit, write_fn, remove_fn)
+
+        # apply_patch can include multiple operations. If we added markdown files,
+        # return a MultiUIExtra so UI can render markdown previews (without showing a diff for those markdown adds).
+        if md_items:
+            items: list[model.MultiUIExtraItem] = []
+            items.extend(md_items)
+            if diff_ui.files:
+                items.append(diff_ui)
+            return "Done!", model.MultiUIExtra(items=items)
+
         return "Done!", diff_ui
 
     @staticmethod
@@ -110,6 +130,9 @@ class ApplyPatchHandler:
         for path in sorted(commit.changes):
             change = commit.changes[path]
             if change.type == apply_patch_module.ActionType.ADD:
+                # For markdown files created via Add File, we render content via MarkdownDocUIExtra instead of a diff.
+                if path.endswith(".md"):
+                    continue
                 files.append(build_structured_file_diff("", change.new_content or "", file_path=path))
             elif change.type == apply_patch_module.ActionType.DELETE:
                 files.append(build_structured_file_diff(change.old_content or "", "", file_path=path))

klaude_code/protocol/model.py

@@ -151,6 +151,28 @@ class SessionStatusUIExtra(BaseModel):
     by_model: list["TaskMetadata"] = []
 
 
+MultiUIExtraItem = (
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | TruncationUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra
+)
+
+
+class MultiUIExtra(BaseModel):
+    """A container UIExtra that can render multiple UI blocks for a single tool result.
+
+    This is primarily used by tools like apply_patch which can perform multiple
+    operations in one invocation.
+    """
+
+    type: Literal["multi"] = "multi"
+    items: list[MultiUIExtraItem]
+
+
 ToolResultUIExtra = Annotated[
     DiffUIExtra
     | TodoListUIExtra
@@ -158,7 +180,8 @@ ToolResultUIExtra = Annotated[
     | MermaidLinkUIExtra
     | TruncationUIExtra
     | MarkdownDocUIExtra
-    | SessionStatusUIExtra,
+    | SessionStatusUIExtra
+    | MultiUIExtra,
     Field(discriminator="type"),
 ]
 

klaude_code/protocol/op.py

@@ -25,6 +25,7 @@ class OperationType(Enum):
     USER_INPUT = "user_input"
     RUN_AGENT = "run_agent"
     CHANGE_MODEL = "change_model"
+    CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
     EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
@@ -77,6 +78,16 @@ class ChangeModelOperation(Operation):
         await handler.handle_change_model(self)
 
 
+class ChangeThinkingOperation(Operation):
+    """Operation for changing the thinking/reasoning configuration."""
+
+    type: OperationType = OperationType.CHANGE_THINKING
+    session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_thinking(self)
+
+
 class ClearSessionOperation(Operation):
     """Operation for clearing the active session and starting a new one."""
 

klaude_code/protocol/op_handler.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Protocol
 if TYPE_CHECKING:
     from klaude_code.protocol.op import (
         ChangeModelOperation,
+        ChangeThinkingOperation,
         ClearSessionOperation,
         ExportSessionOperation,
         InitAgentOperation,
@@ -35,6 +36,10 @@ class OperationHandler(Protocol):
         """Handle a change model operation."""
         ...
 
+    async def handle_change_thinking(self, operation: ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation."""
+        ...
+
     async def handle_clear_session(self, operation: ClearSessionOperation) -> None:
         """Handle a clear session operation."""
         ...

klaude_code/ui/modes/repl/display.py

@@ -57,3 +57,5 @@ class REPLDisplay(DisplayABC):
         # Spinner may already be stopped or not started; ignore.
         with contextlib.suppress(Exception):
             self.renderer.spinner_stop()
+        with contextlib.suppress(Exception):
+            self.renderer.stop_bottom_live()

klaude_code/ui/modes/repl/event_handler.py

@@ -122,6 +122,7 @@ class ActivityState:
 
     def __init__(self) -> None:
         self._composing: bool = False
+        self._buffer_length: int = 0
         self._tool_calls: dict[str, int] = {}
 
     @property
@@ -134,6 +135,11 @@ class ActivityState:
 
     def set_composing(self, composing: bool) -> None:
         self._composing = composing
+        if not composing:
+            self._buffer_length = 0
+
+    def set_buffer_length(self, length: int) -> None:
+        self._buffer_length = length
 
     def add_tool_call(self, tool_name: str) -> None:
         self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
@@ -143,6 +149,7 @@ class ActivityState:
 
     def reset(self) -> None:
         self._composing = False
+        self._buffer_length = 0
         self._tool_calls = {}
 
     def get_activity_text(self) -> Text | None:
@@ -159,7 +166,12 @@ class ActivityState:
                 first = False
             return activity_text
         if self._composing:
-            return Text("Composing")
+            # Main status text with creative verb
+            text = Text.assemble(
+                ("Composing ", ThemeKey.STATUS_TEXT_BOLD),
+                (f"({self._buffer_length:,})", ThemeKey.STATUS_TEXT),
+            )
+            return text
         return None
 
 
@@ -206,6 +218,10 @@ class SpinnerStatusState:
             self._reasoning_status = None
         self._activity.set_composing(composing)
 
+    def set_buffer_length(self, length: int) -> None:
+        """Set buffer length for composing state display."""
+        self._activity.set_buffer_length(length)
+
     def add_tool_call(self, tool_name: str) -> None:
         """Add a tool call to the accumulator."""
         self._activity.add_tool_call(tool_name)
@@ -368,22 +384,20 @@ class DisplayEventHandler:
 
         first_delta = not self.thinking_stream.is_active
         if first_delta:
-            self.renderer.console.push_theme(self.renderer.themes.thinking_markdown_theme)
             mdstream = MarkdownStream(
                 mdargs={
                     "code_theme": self.renderer.themes.code_theme,
-                    "style": self.renderer.console.get_style(ThemeKey.THINKING),
+                    "style": ThemeKey.THINKING,
                 },
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
-                spinner=self.renderer.spinner_renderable(),
+                live_sink=self.renderer.set_stream_renderable if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED else None,
                 mark=THINKING_MESSAGE_MARK,
                 mark_style=ThemeKey.THINKING,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
                 markdown_class=ThinkingMarkdown,
             )
             self.thinking_stream.start(mdstream)
-            self.renderer.spinner_stop()
 
         self.thinking_stream.append(event.content)
 
@@ -414,17 +428,16 @@ class DisplayEventHandler:
                 mdargs={"code_theme": self.renderer.themes.code_theme},
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
-                spinner=self.renderer.spinner_renderable(),
+                live_sink=self.renderer.set_stream_renderable if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED else None,
                 mark=ASSISTANT_MESSAGE_MARK,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
             )
             self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
+        self.spinner_status.set_buffer_length(len(self.assistant_stream.buffer))
+        if not first_delta:
+            self._update_spinner()
         if first_delta and self.assistant_stream.mdstream is not None:
-            # Stop spinner and immediately start MarkdownStream's Live
-            # to avoid flicker. The update() call starts the Live with
-            # the spinner embedded, providing seamless transition.
-            self.renderer.spinner_stop()
             self.assistant_stream.mdstream.update(self.assistant_stream.buffer)
         await self.stage_manager.transition_to(Stage.ASSISTANT)
         await self._flush_assistant_buffer(self.assistant_stream)
@@ -488,7 +501,6 @@ class DisplayEventHandler:
             self.spinner_status.reset()
             self.renderer.spinner_stop()
             self.renderer.console.print(Rule(characters="-", style=ThemeKey.LINES))
-            self.renderer.print()
         await self.stage_manager.transition_to(Stage.WAITING)
         self._maybe_notify_task_finish(event)
 
@@ -552,7 +564,6 @@ class DisplayEventHandler:
             assert mdstream is not None
             mdstream.update(normalize_thinking_content(self.thinking_stream.buffer), final=True)
             self.thinking_stream.finish()
-            self.renderer.console.pop_theme()
             self.renderer.print()
             self.renderer.spinner_start()
 

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import shutil
 from collections.abc import AsyncIterator, Callable
 from pathlib import Path
@@ -51,8 +52,12 @@ class PromptToolkitInput(InputProviderABC):
         self,
         prompt: str = USER_MESSAGE_MARK,
         status_provider: Callable[[], REPLStatusSnapshot] | None = None,
+        pre_prompt: Callable[[], None] | None = None,
+        post_prompt: Callable[[], None] | None = None,
     ):  # ▌
         self._status_provider = status_provider
+        self._pre_prompt = pre_prompt
+        self._post_prompt = post_prompt
         self._is_light_terminal_background = is_light_terminal_background(timeout=0.2)
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
@@ -80,7 +85,7 @@ class PromptToolkitInput(InputProviderABC):
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
             multiline=True,
-            cursor=CursorShape.BEAM,
+            cursor=CursorShape.BLINKING_BEAM,
             prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
             completer=ThreadedCompleter(create_repl_completer()),
@@ -202,8 +207,14 @@ class PromptToolkitInput(InputProviderABC):
     @override
     async def iter_inputs(self) -> AsyncIterator[UserInputPayload]:
         while True:
+            if self._pre_prompt is not None:
+                with contextlib.suppress(Exception):
+                    self._pre_prompt()
             with patch_stdout():
                 line: str = await self._session.prompt_async(placeholder=self._render_input_placeholder())
+            if self._post_prompt is not None:
+                with contextlib.suppress(Exception):
+                    self._post_prompt()
 
             # Extract images referenced in the input text
             images = extract_images_from_text(line)