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

klaude_code/llm/codex/client.py

@@ -114,7 +114,7 @@ class CodexClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         # Ensure token is valid before API call
         self._ensure_valid_token()
 
@@ -142,7 +142,7 @@ class CodexClient(LLMClientABC):
                 extra_headers=extra_headers,
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):

klaude_code/llm/input_common.py

@@ -5,10 +5,10 @@ This module provides shared abstractions for providers that require message grou
 since it uses a flat item list matching our internal protocol.
 """
 
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from klaude_code import const
 

klaude_code/llm/openai_compatible/client.py

@@ -72,7 +72,7 @@ class OpenAICompatibleClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -115,10 +115,10 @@ class OpenAICompatibleClient(LLMClientABC):
                     continue
 
                 # Support Moonshot Kimi K2's usage field in choice
-                if hasattr(event.choices[0], "usage") and getattr(event.choices[0], "usage"):
+                if usage := getattr(event.choices[0], "usage", None):
                     metadata_tracker.set_usage(
                         convert_usage(
-                            openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
+                            openai.types.CompletionUsage.model_validate(usage),
                             param.context_limit,
                             param.max_tokens,
                         )
@@ -127,15 +127,18 @@ class OpenAICompatibleClient(LLMClientABC):
                 delta = event.choices[0].delta
 
                 # Reasoning
-                reasoning_content = (
-                    getattr(delta, "reasoning_content", None)
+                if (
+                    reasoning_content := getattr(delta, "reasoning_content", None)
                     or getattr(delta, "reasoning", None)
                     or ""
-                )
-                if reasoning_content:
+                ):
                     metadata_tracker.record_token()
                     state.stage = "reasoning"
                     state.accumulated_reasoning.append(reasoning_content)
+                    yield model.ReasoningTextDelta(
+                        content=reasoning_content,
+                        response_id=state.response_id,
+                    )
 
                 # Assistant
                 if delta.content and (
@@ -176,7 +179,7 @@ class OpenAICompatibleClient(LLMClientABC):
                             )
                     state.accumulated_tool_calls.add(delta.tool_calls)
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
         # Finalize
         for item in state.flush_all():

klaude_code/llm/openai_compatible/stream_processor.py

@@ -5,7 +5,8 @@ logic for accumulating and flushing reasoning, assistant content, and tool calls
 across different LLM providers (OpenAI-compatible, OpenRouter).
 """
 
-from typing import Callable, Literal
+from collections.abc import Callable
+from typing import Literal
 
 from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
 from klaude_code.protocol import model

klaude_code/llm/openrouter/client.py

@@ -26,7 +26,10 @@ def build_payload(
     tools = convert_tool_schema(param.tools)
 
     extra_body: dict[str, object] = {
-        "usage": {"include": True}  # To get the cache tokens at the end of the response
+        "usage": {"include": True},  # To get the cache tokens at the end of the response
+        "debug": {
+            "echo_upstream_body": True
+        },  # https://openrouter.ai/docs/api/reference/errors-and-debugging#debug-option-shape
     }
     extra_headers: dict[str, str] = {}
 
@@ -45,9 +48,7 @@ def build_payload(
         extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
 
     if is_claude_model(param.model):
-        extra_headers["anthropic-beta"] = (
-            "interleaved-thinking-2025-05-14"  # Not working yet, maybe OpenRouter's issue, or Anthropic: Interleaved thinking is only supported for tools used via the Messages API.
-        )
+        extra_headers["x-anthropic-beta"] = "fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14"
 
     payload: CompletionCreateParamsStreaming = {
         "model": str(param.model),
@@ -81,7 +82,7 @@ class OpenRouterClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -133,13 +134,24 @@ class OpenRouterClient(LLMClientABC):
                 delta = event.choices[0].delta
 
                 # Reasoning
-                if hasattr(delta, "reasoning_details") and getattr(delta, "reasoning_details"):
-                    reasoning_details = getattr(delta, "reasoning_details")
+                if reasoning_details := getattr(delta, "reasoning_details", None):
                     for item in reasoning_details:
                         try:
                             reasoning_detail = ReasoningDetail.model_validate(item)
                             metadata_tracker.record_token()
                             state.stage = "reasoning"
+                            # Yield delta immediately for streaming
+                            if reasoning_detail.text:
+                                yield model.ReasoningTextDelta(
+                                    content=reasoning_detail.text,
+                                    response_id=state.response_id,
+                                )
+                            if reasoning_detail.summary:
+                                yield model.ReasoningTextDelta(
+                                    content=reasoning_detail.summary,
+                                    response_id=state.response_id,
+                                )
+                            # Keep existing handler logic for final items
                             for conversation_item in reasoning_handler.on_detail(reasoning_detail):
                                 yield conversation_item
                         except Exception as e:
@@ -182,7 +194,7 @@ class OpenRouterClient(LLMClientABC):
                     state.accumulated_tool_calls.add(delta.tool_calls)
 
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
         # Finalize
         for item in state.flush_all():

klaude_code/llm/openrouter/reasoning_handler.py

@@ -1,5 +1,3 @@
-from enum import Enum
-
 from pydantic import BaseModel
 
 from klaude_code.protocol import model
@@ -18,14 +16,8 @@ class ReasoningDetail(BaseModel):
     signature: str | None = None  # Claude's signature
 
 
-class ReasoningMode(str, Enum):
-    COMPLETE_CHUNK = "complete_chunk"
-    GPT5_SECTIONS = "gpt5_sections"
-    ACCUMULATE = "accumulate"
-
-
 class ReasoningStreamHandler:
-    """Encapsulates reasoning stream handling across different model behaviors."""
+    """Accumulates reasoning text and flushes on encrypted content or finalize."""
 
     def __init__(
         self,
@@ -37,59 +29,48 @@ class ReasoningStreamHandler:
 
         self._reasoning_id: str | None = None
         self._accumulated_reasoning: list[str] = []
-        self._gpt5_line_buffer: str = ""
-        self._gpt5_section_lines: list[str] = []
 
     def set_response_id(self, response_id: str | None) -> None:
         """Update the response identifier used for emitted items."""
-
         self._response_id = response_id
 
     def on_detail(self, detail: ReasoningDetail) -> list[model.ConversationItem]:
         """Process a single reasoning detail and return streamable items."""
-
         items: list[model.ConversationItem] = []
 
         if detail.type == "reasoning.encrypted":
             self._reasoning_id = detail.id
+            # Flush accumulated text before encrypted content
+            items.extend(self._flush_text())
             if encrypted_item := self._build_encrypted_item(detail.data, detail):
                 items.append(encrypted_item)
             return items
 
         if detail.type in ("reasoning.text", "reasoning.summary"):
             self._reasoning_id = detail.id
-            if encrypted_item := self._build_encrypted_item(detail.signature, detail):
-                items.append(encrypted_item)
+            # Accumulate text
             text = detail.text if detail.type == "reasoning.text" else detail.summary
             if text:
-                items.extend(self._handle_text(text))
+                self._accumulated_reasoning.append(text)
+            # Flush on signature (encrypted content)
+            if detail.signature:
+                items.extend(self._flush_text())
+                if encrypted_item := self._build_encrypted_item(detail.signature, detail):
+                    items.append(encrypted_item)
 
         return items
 
     def flush(self) -> list[model.ConversationItem]:
-        """Flush buffered reasoning text and encrypted payloads."""
+        """Flush buffered reasoning text on finalize."""
+        return self._flush_text()
 
-        items: list[model.ConversationItem] = []
-        mode = self._resolve_mode()
-
-        if mode is ReasoningMode.GPT5_SECTIONS:
-            for section in self._drain_gpt5_sections():
-                items.append(self._build_text_item(section))
-        elif self._accumulated_reasoning and mode is ReasoningMode.ACCUMULATE:
-            items.append(self._build_text_item("".join(self._accumulated_reasoning)))
-            self._accumulated_reasoning = []
-
-        return items
-
-    def _handle_text(self, text: str) -> list[model.ReasoningTextItem]:
-        mode = self._resolve_mode()
-        if mode is ReasoningMode.COMPLETE_CHUNK:
-            return [self._build_text_item(text)]
-        if mode is ReasoningMode.GPT5_SECTIONS:
-            sections = self._process_gpt5_text(text)
-            return [self._build_text_item(section) for section in sections]
-        self._accumulated_reasoning.append(text)
-        return []
+    def _flush_text(self) -> list[model.ConversationItem]:
+        """Flush accumulated reasoning text as a single item."""
+        if not self._accumulated_reasoning:
+            return []
+        item = self._build_text_item("".join(self._accumulated_reasoning))
+        self._accumulated_reasoning = []
+        return [item]
 
     def _build_text_item(self, content: str) -> model.ReasoningTextItem:
         return model.ReasoningTextItem(
@@ -113,97 +94,3 @@ class ReasoningStreamHandler:
             response_id=self._response_id,
             model=self._param_model,
         )
-
-    def _process_gpt5_text(self, text: str) -> list[str]:
-        emitted_sections: list[str] = []
-        self._gpt5_line_buffer += text
-        while True:
-            newline_index = self._gpt5_line_buffer.find("\n")
-            if newline_index == -1:
-                break
-            line = self._gpt5_line_buffer[:newline_index]
-            self._gpt5_line_buffer = self._gpt5_line_buffer[newline_index + 1 :]
-            remainder = line
-            while True:
-                split_result = self._split_gpt5_title_line(remainder)
-                if split_result is None:
-                    break
-                prefix_segment, title_segment, remainder = split_result
-                if prefix_segment:
-                    if not self._gpt5_section_lines:
-                        self._gpt5_section_lines = []
-                    self._gpt5_section_lines.append(f"{prefix_segment}\n")
-                if self._gpt5_section_lines:
-                    emitted_sections.append("".join(self._gpt5_section_lines))
-                self._gpt5_section_lines = [f"{title_segment}  \n"]  # Add two spaces for markdown line break
-            if remainder:
-                if not self._gpt5_section_lines:
-                    self._gpt5_section_lines = []
-                self._gpt5_section_lines.append(f"{remainder}\n")
-        return emitted_sections
-
-    def _drain_gpt5_sections(self) -> list[str]:
-        sections: list[str] = []
-        if self._gpt5_line_buffer:
-            if not self._gpt5_section_lines:
-                self._gpt5_section_lines = [self._gpt5_line_buffer]
-            else:
-                self._gpt5_section_lines.append(self._gpt5_line_buffer)
-            self._gpt5_line_buffer = ""
-        if self._gpt5_section_lines:
-            sections.append("".join(self._gpt5_section_lines))
-            self._gpt5_section_lines = []
-        return sections
-
-    def _is_gpt5(self) -> bool:
-        return "gpt-5" in self._param_model.lower()
-
-    def _is_complete_chunk_reasoning_model(self) -> bool:
-        """Whether the current model emits reasoning in complete chunks (e.g. Gemini)."""
-
-        return self._param_model.startswith("google/gemini")
-
-    def _resolve_mode(self) -> ReasoningMode:
-        if self._is_complete_chunk_reasoning_model():
-            return ReasoningMode.COMPLETE_CHUNK
-        if self._is_gpt5():
-            return ReasoningMode.GPT5_SECTIONS
-        return ReasoningMode.ACCUMULATE
-
-    def _is_gpt5_title_line(self, line: str) -> bool:
-        stripped = line.strip()
-        if not stripped:
-            return False
-        return stripped.startswith("**") and stripped.endswith("**") and stripped.count("**") >= 2
-
-    def _split_gpt5_title_line(self, line: str) -> tuple[str | None, str, str] | None:
-        if not line:
-            return None
-        search_start = 0
-        while True:
-            opening_index = line.find("**", search_start)
-            if opening_index == -1:
-                return None
-            closing_index = line.find("**", opening_index + 2)
-            if closing_index == -1:
-                return None
-            title_candidate = line[opening_index : closing_index + 2]
-            stripped_title = title_candidate.strip()
-            if self._is_gpt5_title_line(stripped_title):
-                # Treat as a GPT-5 title only when everything after the
-                # bold segment is either whitespace or starts a new bold
-                # title. This prevents inline bold like `**xxx**yyyy`
-                # from being misclassified as a section title while
-                # preserving support for consecutive titles in one line.
-                after = line[closing_index + 2 :]
-                if after.strip() and not after.lstrip().startswith("**"):
-                    search_start = closing_index + 2
-                    continue
-                prefix_segment = line[:opening_index]
-                remainder_segment = after
-                return (
-                    prefix_segment if prefix_segment else None,
-                    stripped_title,
-                    remainder_segment,
-                )
-            search_start = closing_index + 2

klaude_code/llm/registry.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Callable, TypeVar
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
 
 from klaude_code.protocol import llm_param
 
@@ -20,13 +21,13 @@ def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
 
     # Import only the needed module to trigger @register decorator
     if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        from . import anthropic as _  # noqa: F401
+        from . import anthropic as _
     elif protocol == llm_param.LLMClientProtocol.CODEX:
-        from . import codex as _  # noqa: F401
+        from . import codex as _
     elif protocol == llm_param.LLMClientProtocol.OPENAI:
-        from . import openai_compatible as _  # noqa: F401
+        from . import openai_compatible as _
     elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        from . import openrouter as _  # noqa: F401
+        from . import openrouter as _
     elif protocol == llm_param.LLMClientProtocol.RESPONSES:
         from . import responses as _  # noqa: F401
 

klaude_code/llm/responses/client.py

@@ -16,7 +16,6 @@ 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
@@ -60,7 +59,7 @@ async def parse_responses_stream(
     stream: "AsyncStream[ResponseStreamEvent]",
     param: llm_param.LLMCallParameter,
     metadata_tracker: MetadataTracker,
-) -> AsyncGenerator[model.ConversationItem, None]:
+) -> AsyncGenerator[model.ConversationItem]:
     """Parse OpenAI Responses API stream events into ConversationItems."""
     response_id: str | None = None
 
@@ -76,6 +75,12 @@ async def parse_responses_stream(
                 case responses.ResponseCreatedEvent() as event:
                     response_id = event.response.id
                     yield model.StartItem(response_id=response_id)
+                case responses.ResponseReasoningSummaryTextDeltaEvent() as event:
+                    if event.delta:
+                        yield model.ReasoningTextDelta(
+                            content=event.delta,
+                            response_id=response_id,
+                        )
                 case responses.ResponseReasoningSummaryTextDoneEvent() as event:
                     if event.text:
                         yield model.ReasoningTextItem(
@@ -164,7 +169,7 @@ async def parse_responses_stream(
                         debug_type=DebugType.LLM_STREAM,
                     )
     except (openai.OpenAIError, httpx.HTTPError) as e:
-        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
 
 @register(llm_param.LLMClientProtocol.RESPONSES)
@@ -194,7 +199,7 @@ class ResponsesClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -212,7 +217,7 @@ class ResponsesClient(LLMClientABC):
                 extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):

klaude_code/protocol/events.py

@@ -54,6 +54,12 @@ class ThinkingEvent(BaseModel):
     content: str
 
 
+class ThinkingDeltaEvent(BaseModel):
+    session_id: str
+    response_id: str | None = None
+    content: str
+
+
 class AssistantMessageDeltaEvent(BaseModel):
     session_id: str
     response_id: str | None = None
@@ -153,6 +159,7 @@ Event = (
     TaskStartEvent
     | TaskFinishEvent
     | ThinkingEvent
+    | ThinkingDeltaEvent
     | AssistantMessageDeltaEvent
     | AssistantMessageEvent
     | ToolCallEvent

klaude_code/protocol/model.py

@@ -296,6 +296,12 @@ class AssistantMessageDelta(BaseModel):
     created_at: datetime = Field(default_factory=datetime.now)
 
 
+class ReasoningTextDelta(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)
@@ -392,7 +398,7 @@ MessageItem = (
 )
 
 
-StreamItem = AssistantMessageDelta
+StreamItem = AssistantMessageDelta | ReasoningTextDelta
 
 ConversationItem = (
     StartItem

klaude_code/protocol/sub_agent.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from klaude_code.protocol import tools
 

klaude_code/session/selector.py

@@ -40,7 +40,7 @@ def resume_select_session() -> str | None:
                 ("class:b", f"{msg_count_display:>{MSG_COUNT_WIDTH}}  "),
                 (
                     "class:t",
-                    f"{model_display[:MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}}  ",
+                    f"{model_display[: MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}}  ",
                 ),
                 (
                     "class:t",
@@ -69,7 +69,7 @@ def resume_select_session() -> str | None:
             model_display = s.model_name or "N/A"
             print(
                 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}"
+                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

@@ -261,12 +261,10 @@ class Session(BaseModel):
             return False
         if prev_item is None:
             return True
-        if isinstance(
+        return isinstance(
             prev_item,
             model.UserMessageItem | model.ToolResultItem | model.DeveloperMessageItem,
-        ):
-            return True
-        return False
+        )
 
     def get_history_item(self) -> Iterable[events.HistoryItemEvent]:
         prev_item: model.ConversationItem | None = None

klaude_code/trace/__init__.py

@@ -1,3 +1,3 @@
 from .log import DebugType, is_debug_enabled, log, log_debug, logger, set_debug_logging
 
-__all__ = ["log", "log_debug", "logger", "set_debug_logging", "DebugType", "is_debug_enabled"]
+__all__ = ["DebugType", "is_debug_enabled", "log", "log_debug", "logger", "set_debug_logging"]

klaude_code/trace/log.py

@@ -1,7 +1,7 @@
 import logging
+from collections.abc import Iterable
 from enum import Enum
 from logging.handlers import RotatingFileHandler
-from typing import Iterable
 
 from rich.console import Console
 from rich.logging import RichHandler

klaude_code/ui/__init__.py

@@ -73,19 +73,14 @@ def create_exec_display(debug: bool = False, stream_json: bool = False) -> Displ
 
 
 __all__ = [
-    # Abstract interfaces
+    "DebugEventDisplay",
     "DisplayABC",
+    "ExecDisplay",
     "InputProviderABC",
-    # Display mode implementations
+    "PromptToolkitInput",
     "REPLDisplay",
-    "ExecDisplay",
     "StreamJsonDisplay",
-    "DebugEventDisplay",
-    # Input implementations
-    "PromptToolkitInput",
-    # Factory functions
+    "TerminalNotifier",
     "create_default_display",
     "create_exec_display",
-    # Supporting types
-    "TerminalNotifier",
 ]

klaude_code/ui/core/stage_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from enum import Enum
-from typing import Awaitable, Callable
 
 
 class Stage(Enum):
@@ -19,10 +19,12 @@ class StageManager:
         self,
         *,
         finish_assistant: Callable[[], Awaitable[None]],
+        finish_thinking: Callable[[], Awaitable[None]],
         on_enter_thinking: Callable[[], None],
     ):
         self._stage = Stage.WAITING
         self._finish_assistant = finish_assistant
+        self._finish_thinking = finish_thinking
         self._on_enter_thinking = on_enter_thinking
 
     @property
@@ -49,7 +51,8 @@ class StageManager:
         self._stage = Stage.WAITING
 
     async def _leave_current_stage(self) -> None:
-        if self._stage == Stage.ASSISTANT:
+        if self._stage == Stage.THINKING:
+            await self._finish_thinking()
+        elif self._stage == Stage.ASSISTANT:
             await self.finish_assistant()
-        elif self._stage != Stage.WAITING:
-            self._stage = Stage.WAITING
+        self._stage = Stage.WAITING

klaude_code/ui/modes/repl/__init__.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None) -> REPLStatusSnapshot:
+def build_repl_status_snapshot(agent: Agent | None, update_message: str | None) -> REPLStatusSnapshot:
     """Build a status snapshot for the REPL bottom toolbar.
 
     Aggregates model name, context usage, and basic call counts from the

klaude_code/ui/modes/repl/completers.py

@@ -133,10 +133,9 @@ class _ComboCompleter(Completer):
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
         # Try slash command completion first (only on first line)
-        if document.cursor_position_row == 0:
-            if self._slash_completer.is_slash_command_context(document):
-                yield from self._slash_completer.get_completions(document, complete_event)
-                return
+        if document.cursor_position_row == 0 and self._slash_completer.is_slash_command_context(document):
+            yield from self._slash_completer.get_completions(document, complete_event)
+            return
 
         # Fall back to @ file completion
         yield from self._at_completer.get_completions(document, complete_event)

klaude_code/ui/modes/repl/display.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from typing import override
 
 from klaude_code.protocol import events
@@ -53,8 +54,6 @@ class REPLDisplay(DisplayABC):
     async def stop(self) -> None:
         await self.event_handler.stop()
         # Ensure any active spinner is stopped so Rich restores the cursor.
-        try:
+        # Spinner may already be stopped or not started; ignore.
+        with contextlib.suppress(Exception):
             self.renderer.spinner_stop()
-        except Exception:
-            # Spinner may already be stopped or not started; ignore.
-            pass