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

klaude_code/llm/openrouter/client.py

@@ -1,6 +1,6 @@
 import json
 from collections.abc import AsyncGenerator
-from typing import override
+from typing import Any, override
 
 import httpx
 import openai
@@ -9,13 +9,13 @@ from openai.types.chat.completion_create_params import CompletionCreateParamsStr
 from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.openai_compatible.input import convert_tool_schema
-from klaude_code.llm.openai_compatible.stream_processor import StreamStateManager
+from klaude_code.llm.openai_compatible.stream import parse_chat_completions_stream
 from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude_model
-from klaude_code.llm.openrouter.reasoning_handler import ReasoningDetail, ReasoningStreamHandler
+from klaude_code.llm.openrouter.reasoning import ReasoningStreamHandler
 from klaude_code.llm.registry import register
-from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
-from klaude_code.trace import DebugType, is_debug_enabled, log, log_debug
+from klaude_code.trace import DebugType, is_debug_enabled, log_debug
 
 
 def build_payload(
@@ -96,114 +96,34 @@ class OpenRouterClient(LLMClientABC):
             debug_type=DebugType.LLM_PAYLOAD,
         )
 
-        stream = self.client.chat.completions.create(
-            **payload,
-            extra_body=extra_body,
-            extra_headers=extra_headers,
-        )
+        try:
+            stream = await self.client.chat.completions.create(
+                **payload,
+                extra_body=extra_body,
+                extra_headers=extra_headers,
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()
+            return
 
         reasoning_handler = ReasoningStreamHandler(
             param_model=str(param.model),
             response_id=None,
         )
 
-        state = StreamStateManager(
-            param_model=str(param.model),
-            reasoning_flusher=reasoning_handler.flush,
-        )
-
-        try:
-            async for event in await stream:
-                log_debug(
-                    event.model_dump_json(exclude_none=True),
-                    style="blue",
-                    debug_type=DebugType.LLM_STREAM,
-                )
-
-                if not state.response_id and event.id:
-                    state.set_response_id(event.id)
-                    reasoning_handler.set_response_id(event.id)
-                    yield model.StartItem(response_id=event.id)
-                if event.usage is not None:
-                    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):
-                    metadata_tracker.set_provider(str(provider))
-                if len(event.choices) == 0:
-                    continue
-                delta = event.choices[0].delta
-
-                # Reasoning
-                if reasoning_details := getattr(delta, "reasoning_details", None):
-                    for item in reasoning_details:
-                        try:
-                            reasoning_detail = ReasoningDetail.model_validate(item)
-                            if reasoning_detail.text or reasoning_detail.summary:
-                                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:
-                            log("reasoning_details error", str(e), style="red")
-
-                # Assistant
-                if delta.content and (
-                    state.stage == "assistant" or delta.content.strip()
-                ):  # Process all content in assistant stage, filter empty content in reasoning stage
-                    metadata_tracker.record_token()
-                    if state.stage == "reasoning":
-                        for item in state.flush_reasoning():
-                            yield item
-                    state.stage = "assistant"
-                    state.accumulated_content.append(delta.content)
-                    yield model.AssistantMessageDelta(
-                        content=delta.content,
-                        response_id=state.response_id,
-                    )
-
-                # Tool
-                if delta.tool_calls and len(delta.tool_calls) > 0:
-                    metadata_tracker.record_token()
-                    if state.stage == "reasoning":
-                        for item in state.flush_reasoning():
-                            yield item
-                    elif state.stage == "assistant":
-                        for item in state.flush_assistant():
-                            yield item
-                    state.stage = "tool"
-                    # Emit ToolCallStartItem for new tool calls
-                    for tc in delta.tool_calls:
-                        if tc.index not in state.emitted_tool_start_indices and tc.function and tc.function.name:
-                            state.emitted_tool_start_indices.add(tc.index)
-                            yield model.ToolCallStartItem(
-                                response_id=state.response_id,
-                                call_id=tc.id or "",
-                                name=tc.function.name,
-                            )
-                    state.accumulated_tool_calls.add(delta.tool_calls)
-
-        except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
-
-        # Finalize
-        flushed_items = state.flush_all()
-        if flushed_items:
-            metadata_tracker.record_token()
-        for item in flushed_items:
+        def on_event(event: Any) -> None:
+            log_debug(
+                event.model_dump_json(exclude_none=True),
+                style="blue",
+                debug_type=DebugType.LLM_STREAM,
+            )
+
+        async for item in parse_chat_completions_stream(
+            stream,
+            param=param,
+            metadata_tracker=metadata_tracker,
+            reasoning_handler=reasoning_handler,
+            on_event=on_event,
+        ):
             yield item
-
-        metadata_tracker.set_response_id(state.response_id)
-        yield metadata_tracker.finalize()

klaude_code/llm/openrouter/{reasoning_handler.py → reasoning.py}

@@ -1,6 +1,8 @@
 from pydantic import BaseModel
 
+from klaude_code.llm.openai_compatible.stream import ReasoningDeltaResult, ReasoningHandlerABC
 from klaude_code.protocol import model
+from klaude_code.trace import log
 
 
 class ReasoningDetail(BaseModel):
@@ -16,8 +18,8 @@ class ReasoningDetail(BaseModel):
     signature: str | None = None  # Claude's signature
 
 
-class ReasoningStreamHandler:
-    """Accumulates reasoning text and flushes on encrypted content or finalize."""
+class ReasoningStreamHandler(ReasoningHandlerABC):
+    """Accumulates OpenRouter reasoning details and emits ordered outputs."""
 
     def __init__(
         self,
@@ -34,6 +36,26 @@ class ReasoningStreamHandler:
         """Update the response identifier used for emitted items."""
         self._response_id = response_id
 
+    def on_delta(self, delta: object) -> ReasoningDeltaResult:
+        """Parse OpenRouter's reasoning_details and return ordered stream outputs."""
+        reasoning_details = getattr(delta, "reasoning_details", None)
+        if not reasoning_details:
+            return ReasoningDeltaResult(handled=False, outputs=[])
+
+        outputs: list[str | model.ConversationItem] = []
+        for item in reasoning_details:
+            try:
+                reasoning_detail = ReasoningDetail.model_validate(item)
+                if reasoning_detail.text:
+                    outputs.append(reasoning_detail.text)
+                if reasoning_detail.summary:
+                    outputs.append(reasoning_detail.summary)
+                outputs.extend(self.on_detail(reasoning_detail))
+            except Exception as e:
+                log("reasoning_details error", str(e), style="red")
+
+        return ReasoningDeltaResult(handled=True, outputs=outputs)
+
     def on_detail(self, detail: ReasoningDetail) -> list[model.ConversationItem]:
         """Process a single reasoning detail and return streamable items."""
         items: list[model.ConversationItem] = []

klaude_code/protocol/model.py

@@ -138,6 +138,12 @@ class TruncationUIExtra(BaseModel):
     truncated_length: int
 
 
+class MarkdownDocUIExtra(BaseModel):
+    type: Literal["markdown_doc"] = "markdown_doc"
+    file_path: str
+    content: str
+
+
 class SessionStatusUIExtra(BaseModel):
     type: Literal["session_status"] = "session_status"
     usage: "Usage"
@@ -146,7 +152,13 @@ class SessionStatusUIExtra(BaseModel):
 
 
 ToolResultUIExtra = Annotated[
-    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | TruncationUIExtra | SessionStatusUIExtra,
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | TruncationUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra,
     Field(discriminator="type"),
 ]
 

klaude_code/ui/core/stage_manager.py

@@ -20,12 +20,10 @@ class StageManager:
         *,
         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
     def current_stage(self) -> Stage:
@@ -41,7 +39,6 @@ class StageManager:
         if self._stage == Stage.THINKING:
             return
         await self.transition_to(Stage.THINKING)
-        self._on_enter_thinking()
 
     async def finish_assistant(self) -> None:
         if self._stage != Stage.ASSISTANT:

klaude_code/ui/modes/repl/event_handler.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from rich.cells import cell_len
 from rich.rule import Rule
 from rich.text import Text
 
@@ -10,13 +11,48 @@ from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
 from klaude_code.ui.renderers.assistant import ASSISTANT_MESSAGE_MARK
-from klaude_code.ui.renderers.thinking import normalize_thinking_content
+from klaude_code.ui.renderers.thinking import THINKING_MESSAGE_MARK, normalize_thinking_content
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
+def extract_last_bold_header(text: str) -> str | None:
+    """Extract the latest complete bold header ("**...**") from text.
+
+    We treat a bold segment as a "header" only if it appears at the beginning
+    of a line (ignoring leading whitespace). This avoids picking up incidental
+    emphasis inside paragraphs.
+
+    Returns None if no complete bold segment is available yet.
+    """
+
+    last: str | None = None
+    i = 0
+    while True:
+        start = text.find("**", i)
+        if start < 0:
+            break
+
+        line_start = text.rfind("\n", 0, start) + 1
+        if text[line_start:start].strip():
+            i = start + 2
+            continue
+
+        end = text.find("**", start + 2)
+        if end < 0:
+            break
+
+        inner = " ".join(text[start + 2 : end].split())
+        if inner and "\n" not in inner:
+            last = inner
+
+        i = end + 2
+
+    return last
+
+
 @dataclass
 class ActiveStream:
     """Active streaming state containing buffer and markdown renderer.
@@ -117,7 +153,7 @@ class ActivityState:
             for name, count in self._tool_calls.items():
                 if not first:
                     activity_text.append(", ")
-                activity_text.append(Text(name, style=ThemeKey.SPINNER_STATUS_TEXT_BOLD))
+                activity_text.append(Text(name, style=ThemeKey.STATUS_TEXT_BOLD))
                 if count > 1:
                     activity_text.append(f" x {count}")
                 first = False
@@ -130,8 +166,9 @@ class ActivityState:
 class SpinnerStatusState:
     """Multi-layer spinner status state management.
 
-    Composed of two independent layers:
-    - base_status: Set by TodoChange, persistent within a turn
+    Layers:
+    - todo_status: Set by TodoChange (preferred when present)
+    - reasoning_status: Derived from Thinking/ThinkingDelta bold headers
     - activity: Current activity (composing or tool_calls), mutually exclusive
     - context_percent: Context usage percentage, updated during task execution
 
@@ -142,25 +179,31 @@ class SpinnerStatusState:
     - Context percent is appended at the end if available
     """
 
-    DEFAULT_STATUS = "Thinking …"
-
     def __init__(self) -> None:
-        self._base_status: str | None = None
+        self._todo_status: str | None = None
+        self._reasoning_status: str | None = None
         self._activity = ActivityState()
         self._context_percent: float | None = None
 
     def reset(self) -> None:
         """Reset all layers."""
-        self._base_status = None
+        self._todo_status = None
+        self._reasoning_status = None
         self._activity.reset()
         self._context_percent = None
 
-    def set_base_status(self, status: str | None) -> None:
+    def set_todo_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
-        self._base_status = status
+        self._todo_status = status
+
+    def set_reasoning_status(self, status: str | None) -> None:
+        """Set reasoning-derived base status from ThinkingDelta bold headers."""
+        self._reasoning_status = status
 
     def set_composing(self, composing: bool) -> None:
         """Set composing state when assistant is streaming."""
+        if composing:
+            self._reasoning_status = None
         self._activity.set_composing(composing)
 
     def add_tool_call(self, tool_name: str) -> None:
@@ -187,8 +230,10 @@ class SpinnerStatusState:
         """Get current spinner status as rich Text (without context)."""
         activity_text = self._activity.get_activity_text()
 
-        if self._base_status:
-            result = Text(self._base_status)
+        base_status = self._todo_status or self._reasoning_status
+
+        if base_status:
+            result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD)
             if activity_text:
                 result.append(" | ")
                 result.append_text(activity_text)
@@ -196,7 +241,7 @@ class SpinnerStatusState:
             activity_text.append(" …")
             result = activity_text
         else:
-            result = Text(self.DEFAULT_STATUS)
+            result = Text(const.STATUS_DEFAULT_TEXT, style=ThemeKey.STATUS_TEXT)
 
         return result
 
@@ -220,7 +265,6 @@ class DisplayEventHandler:
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
             finish_thinking=self._finish_thinking_stream,
-            on_enter_thinking=self._print_thinking_prefix,
         )
 
     async def consume_event(self, event: events.Event) -> None:
@@ -311,6 +355,10 @@ class DisplayEventHandler:
             await self._finish_thinking_stream()
         else:
             # Non-streaming path (history replay or models without delta support)
+            reasoning_status = extract_last_bold_header(normalize_thinking_content(event.content))
+            if reasoning_status:
+                self.spinner_status.set_reasoning_status(reasoning_status)
+                self._update_spinner()
             await self.stage_manager.enter_thinking_stage()
             self.renderer.display_thinking(event.content)
 
@@ -329,6 +377,8 @@ class DisplayEventHandler:
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
                 spinner=self.renderer.spinner_renderable(),
+                mark=THINKING_MESSAGE_MARK,
+                mark_style=ThemeKey.THINKING,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
                 markdown_class=ThinkingMarkdown,
             )
@@ -337,6 +387,11 @@ class DisplayEventHandler:
 
         self.thinking_stream.append(event.content)
 
+        reasoning_status = extract_last_bold_header(normalize_thinking_content(self.thinking_stream.buffer))
+        if reasoning_status:
+            self.spinner_status.set_reasoning_status(reasoning_status)
+            self._update_spinner()
+
         if first_delta and self.thinking_stream.mdstream is not None:
             self.thinking_stream.mdstream.update(normalize_thinking_content(self.thinking_stream.buffer))
 
@@ -415,7 +470,7 @@ class DisplayEventHandler:
 
     def _on_todo_change(self, event: events.TodoChangeEvent) -> None:
         active_form_status_text = self._extract_active_form_text(event)
-        self.spinner_status.set_base_status(active_form_status_text if active_form_status_text else None)
+        self.spinner_status.set_todo_status(active_form_status_text if active_form_status_text else None)
         # Clear tool calls when todo changes, as the tool execution has advanced
         self.spinner_status.clear_for_new_turn()
         self._update_spinner()
@@ -469,14 +524,14 @@ class DisplayEventHandler:
             mdstream.update(self.assistant_stream.buffer, final=True)
             self.assistant_stream.finish()
 
-    def _print_thinking_prefix(self) -> None:
-        self.renderer.display_thinking_prefix()
-
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
+        status_text = self.spinner_status.get_status()
+        context_text = self.spinner_status.get_context_text()
+        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
         self.renderer.spinner_update(
-            self.spinner_status.get_status(),
-            self.spinner_status.get_context_text(),
+            status_text,
+            context_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -534,35 +589,28 @@ class DisplayEventHandler:
                     status_text = todo.active_form
                 if len(todo.content) > 0:
                     status_text = todo.content
-        status_text = status_text.replace("\n", "")
-        max_length = self._calculate_base_status_max_length()
-        return self._truncate_status_text(status_text, max_length=max_length)
-
-    def _calculate_base_status_max_length(self) -> int:
-        """Calculate max length for base_status based on terminal width.
-
-        Reserve space for:
-        - Spinner glyph + space + context text: 2 chars + context text length 10 chars
-        - " | " separator: 3 chars (only if activity text present)
-        - Activity text: actual length (only if present)
-        - Status hint text (esc to interrupt)
+        return status_text.replace("\n", " ").strip()
+
+    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
+        """Truncate spinner status to a single line based on terminal width.
+
+        Rich wraps based on terminal cell width (CJK chars count as 2). Use
+        cell-aware truncation to prevent the status from wrapping into two lines.
         """
+
         terminal_width = self.renderer.console.size.width
 
-        # Base reserved space: spinner + context + status hint
-        reserved_space = 12 + len(const.STATUS_HINT_TEXT)
+        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
+        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
+        spinner_prefix_cells = 2
 
-        # Add space for activity text if present
-        activity_text = self.spinner_status.get_activity_text()
-        if activity_text:
-            # " | " separator + actual activity text length
-            reserved_space += 3 + len(activity_text.plain)
+        hint_cells = cell_len(const.STATUS_HINT_TEXT)
+        right_cells = cell_len(right_text.plain) if right_text is not None else 0
 
-        max_length = max(10, terminal_width - reserved_space)
-        return max_length
+        max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1
+        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
+        max_main_cells = max(1, max_main_cells)
 
-    def _truncate_status_text(self, text: str, max_length: int) -> str:
-        if len(text) <= max_length:
-            return text
-        truncated = text[:max_length]
-        return truncated + "…"
+        truncated = status_text.copy()
+        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
+        return truncated

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -33,7 +33,9 @@ class REPLStatusSnapshot(NamedTuple):
     update_message: str | None = None
 
 
-COMPLETION_SELECTED = "#5869f7"
+COMPLETION_SELECTED_DARK_BG = "#8b9bff"
+COMPLETION_SELECTED_LIGHT_BG = "#5869f7"
+COMPLETION_SELECTED_UNKNOWN_BG = "#7080f0"
 COMPLETION_MENU = "ansibrightblack"
 INPUT_PROMPT_STYLE = "ansimagenta bold"
 PLACEHOLDER_TEXT_STYLE_DARK_BG = "fg:#5a5a5a italic"
@@ -66,6 +68,14 @@ class PromptToolkitInput(InputProviderABC):
             at_token_pattern=AT_TOKEN_PATTERN,
         )
 
+        # Select completion selected color based on terminal background
+        if self._is_light_terminal_background is True:
+            completion_selected = COMPLETION_SELECTED_LIGHT_BG
+        elif self._is_light_terminal_background is False:
+            completion_selected = COMPLETION_SELECTED_DARK_BG
+        else:
+            completion_selected = COMPLETION_SELECTED_UNKNOWN_BG
+
         self._session: PromptSession[str] = PromptSession(
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
@@ -86,8 +96,8 @@ class PromptToolkitInput(InputProviderABC):
                     "scrollbar.button": "bg:default",
                     "completion-menu.completion": f"bg:default fg:{COMPLETION_MENU}",
                     "completion-menu.meta.completion": f"bg:default fg:{COMPLETION_MENU}",
-                    "completion-menu.completion.current": f"noreverse bg:default fg:{COMPLETION_SELECTED} bold",
-                    "completion-menu.meta.completion.current": f"bg:default fg:{COMPLETION_SELECTED} bold",
+                    "completion-menu.completion.current": f"noreverse bg:default fg:{completion_selected} bold",
+                    "completion-menu.meta.completion.current": f"bg:default fg:{completion_selected} bold",
                 }
             ),
         )