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

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

@@ -15,7 +15,7 @@ from klaude_code.llm.openrouter.reasoning_handler import ReasoningDetail, Reason
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, convert_usage
 from klaude_code.protocol import llm_param, model
-from klaude_code.trace import DebugType, log, log_debug
+from klaude_code.trace import DebugType, is_debug_enabled, log, log_debug
 
 
 def build_payload(
@@ -26,8 +26,12 @@ 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
     }
+    if is_debug_enabled():
+        extra_body["debug"] = {
+            "echo_upstream_body": True
+        }  # https://openrouter.ai/docs/api/reference/errors-and-debugging#debug-option-shape
     extra_headers: dict[str, str] = {}
 
     if param.thinking:
@@ -45,9 +49,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 +83,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 +135,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 +195,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
@@ -79,7 +85,6 @@ class ToolCallEvent(BaseModel):
     tool_call_id: str
     tool_name: str
     arguments: str
-    is_replay: bool = False
 
 
 class ToolResultEvent(BaseModel):
@@ -90,7 +95,6 @@ class ToolResultEvent(BaseModel):
     result: str
     ui_extra: model.ToolResultUIExtra | None = None
     status: Literal["success", "error"]
-    is_replay: bool = False
     task_metadata: model.TaskMetadata | None = None  # Sub-agent task metadata
 
 
@@ -130,6 +134,8 @@ class TodoChangeEvent(BaseModel):
 
 HistoryItemEvent = (
     ThinkingEvent
+    | TaskStartEvent
+    | TaskFinishEvent
     | TurnStartEvent  # This event is used for UI to print new empty line
     | AssistantMessageEvent
     | ToolCallEvent
@@ -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
 
@@ -290,7 +291,6 @@ 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

@@ -544,7 +544,13 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
 def _build_messages_html(
     history: list[model.ConversationItem],
     tool_results: dict[str, model.ToolResultItem],
+    *,
+    seen_session_ids: set[str] | None = None,
+    nesting_level: int = 0,
 ) -> str:
+    if seen_session_ids is None:
+        seen_session_ids = set()
+
     blocks: list[str] = []
     assistant_counter = 0
 
@@ -596,9 +602,61 @@ def _build_messages_html(
             result = tool_results.get(item.call_id)
             blocks.append(_format_tool_call(item, result))
 
+            # Recursively render sub-agent session history
+            if result is not None:
+                sub_agent_html = _render_sub_agent_session(result, seen_session_ids, nesting_level)
+                if sub_agent_html:
+                    blocks.append(sub_agent_html)
+
     return "\n".join(blocks)
 
 
+def _render_sub_agent_session(
+    tool_result: model.ToolResultItem,
+    seen_session_ids: set[str],
+    nesting_level: int,
+) -> str | None:
+    """Render sub-agent session history when a tool result references it."""
+    from klaude_code.session.session import Session
+
+    ui_extra = tool_result.ui_extra
+    if not isinstance(ui_extra, model.SessionIdUIExtra):
+        return None
+
+    session_id = ui_extra.session_id
+    if not session_id or session_id in seen_session_ids:
+        return None
+
+    seen_session_ids.add(session_id)
+
+    try:
+        sub_session = Session.load(session_id)
+    except Exception:
+        return None
+
+    sub_history = sub_session.conversation_history
+    sub_tool_results = {item.call_id: item for item in sub_history if isinstance(item, model.ToolResultItem)}
+
+    sub_html = _build_messages_html(
+        sub_history,
+        sub_tool_results,
+        seen_session_ids=seen_session_ids,
+        nesting_level=nesting_level + 1,
+    )
+
+    if not sub_html:
+        return None
+
+    # Wrap in a collapsible sub-agent container using same style as other collapsible sections
+    indent_style = f' style="margin-left: {nesting_level * 16}px;"' if nesting_level > 0 else ""
+    return (
+        f'<details class="sub-agent-session"{indent_style}>'
+        f"<summary>Sub-agent: {_escape_html(session_id)}</summary>"
+        f'<div class="sub-agent-content">{sub_html}</div>'
+        f"</details>"
+    )
+
+
 def build_export_html(
     session: Session,
     system_prompt: str,

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()