klaude-code 2.9.0__py3-none-any.whl → 2.9.1__py3-none-any.whl

klaude_code/auth/antigravity/oauth.py

@@ -258,42 +258,46 @@ class AntigravityOAuth:
         )
 
     def refresh(self) -> AntigravityAuthState:
-        """Refresh the access token using refresh token."""
-        state = self.token_manager.get_state()
-        if state is None:
-            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        """Refresh the access token using refresh token with file locking.
 
-        data = {
-            "client_id": CLIENT_ID,
-            "client_secret": CLIENT_SECRET,
-            "refresh_token": state.refresh_token,
-            "grant_type": "refresh_token",
-        }
+        Uses file locking to prevent multiple instances from refreshing simultaneously.
+        If another instance has already refreshed, returns the updated state.
+        """
 
-        with httpx.Client() as client:
-            response = client.post(TOKEN_URL, data=data, timeout=30)
+        def do_refresh(current_state: AntigravityAuthState) -> AntigravityAuthState:
+            data = {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "refresh_token": current_state.refresh_token,
+                "grant_type": "refresh_token",
+            }
 
-        if response.status_code != 200:
-            raise AntigravityTokenExpiredError(f"Token refresh failed: {response.text}")
+            with httpx.Client() as client:
+                response = client.post(TOKEN_URL, data=data, timeout=30)
 
-        tokens = response.json()
-        access_token = tokens["access_token"]
-        refresh_token = tokens.get("refresh_token", state.refresh_token)
-        expires_in = tokens.get("expires_in", 3600)
+            if response.status_code != 200:
+                raise AntigravityTokenExpiredError(f"Token refresh failed: {response.text}")
 
-        # Calculate expiry time with 5 minute buffer
-        expires_at = int(time.time()) + expires_in - 300
+            tokens = response.json()
+            access_token = tokens["access_token"]
+            refresh_token = tokens.get("refresh_token", current_state.refresh_token)
+            expires_in = tokens.get("expires_in", 3600)
 
-        new_state = AntigravityAuthState(
-            access_token=access_token,
-            refresh_token=refresh_token,
-            expires_at=expires_at,
-            project_id=state.project_id,
-            email=state.email,
-        )
+            # Calculate expiry time with 5 minute buffer
+            expires_at = int(time.time()) + expires_in - 300
+
+            return AntigravityAuthState(
+                access_token=access_token,
+                refresh_token=refresh_token,
+                expires_at=expires_at,
+                project_id=current_state.project_id,
+                email=current_state.email,
+            )
 
-        self.token_manager.save(new_state)
-        return new_state
+        try:
+            return self.token_manager.refresh_with_lock(do_refresh)
+        except ValueError as e:
+            raise AntigravityNotLoggedInError(str(e)) from e
 
     def ensure_valid_token(self) -> tuple[str, str]:
         """Ensure we have a valid access token, refreshing if needed.

klaude_code/auth/claude/oauth.py

@@ -125,60 +125,45 @@ class ClaudeOAuth:
             expires_at=int(time.time()) + int(expires_in),
         )
 
-    def _do_refresh_request(self, refresh_token: str) -> httpx.Response:
-        """Send token refresh request to OAuth server."""
-        payload = {
-            "grant_type": "refresh_token",
-            "client_id": CLIENT_ID,
-            "refresh_token": refresh_token,
-        }
-        with httpx.Client() as client:
-            return client.post(
-                TOKEN_URL,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-            )
-
     def refresh(self) -> ClaudeAuthState:
-        """Refresh the access token using refresh token.
+        """Refresh the access token using refresh token with file locking.
 
-        Handles concurrent refresh race conditions by retrying with freshly loaded token
-        if the first attempt fails with invalid_grant error.
+        Uses file locking to prevent multiple instances from refreshing simultaneously.
+        If another instance has already refreshed, returns the updated state.
         """
-        state = self.token_manager.get_state()
-        if state is None:
-            raise ClaudeNotLoggedInError("Not logged in to Claude. Run 'klaude login claude' first.")
 
-        response = self._do_refresh_request(state.refresh_token)
-
-        # Handle race condition: another process may have refreshed the token already
-        if response.status_code != 200 and "invalid_grant" in response.text:
-            # Reload token from file (another process may have updated it)
-            self.token_manager.clear_cached_state()
-            fresh_state = self.token_manager.load()
-            if fresh_state and fresh_state.refresh_token != state.refresh_token:
-                # Token was updated by another process
-                if not fresh_state.is_expired():
-                    # New token is still valid, use it directly
-                    return fresh_state
-                # New token expired, try refreshing with the new refresh_token
-                response = self._do_refresh_request(fresh_state.refresh_token)
-
-        if response.status_code != 200:
-            raise ClaudeAuthError(f"Token refresh failed: {response.text}")
-
-        tokens = response.json()
-        access_token = tokens["access_token"]
-        refresh_token = tokens.get("refresh_token", state.refresh_token)
-        expires_in = tokens.get("expires_in", 3600)
+        def do_refresh(current_state: ClaudeAuthState) -> ClaudeAuthState:
+            payload = {
+                "grant_type": "refresh_token",
+                "client_id": CLIENT_ID,
+                "refresh_token": current_state.refresh_token,
+            }
+
+            with httpx.Client() as client:
+                response = client.post(
+                    TOKEN_URL,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                )
+
+            if response.status_code != 200:
+                raise ClaudeAuthError(f"Token refresh failed: {response.text}")
+
+            tokens = response.json()
+            access_token = tokens["access_token"]
+            refresh_token = tokens.get("refresh_token", current_state.refresh_token)
+            expires_in = tokens.get("expires_in", 3600)
+
+            return ClaudeAuthState(
+                access_token=access_token,
+                refresh_token=refresh_token,
+                expires_at=int(time.time()) + int(expires_in),
+            )
 
-        new_state = ClaudeAuthState(
-            access_token=access_token,
-            refresh_token=refresh_token,
-            expires_at=int(time.time()) + int(expires_in),
-        )
-        self.token_manager.save(new_state)
-        return new_state
+        try:
+            return self.token_manager.refresh_with_lock(do_refresh)
+        except ValueError as e:
+            raise ClaudeNotLoggedInError(str(e)) from e
 
     def ensure_valid_token(self) -> str:
         """Ensure we have a valid access token, refreshing if needed."""

klaude_code/config/assets/builtin_config.yaml

@@ -148,6 +148,8 @@ provider_list:
     modalities:
     - image
     - text
+    image_config:
+      image_size: "4K"
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
 
   - model_name: nano-banana
@@ -221,6 +223,8 @@ provider_list:
     modalities:
     - image
     - text
+    image_config:
+      image_size: "4K"
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
 
   - model_name: nano-banana
@@ -275,6 +279,19 @@ provider_list:
     cost: {input: 4, output: 16, cache_read: 1, currency: CNY}
 
 
+- provider_name: cerebras
+  protocol: openai
+  api_key: ${CEREBRAS_API_KEY}
+  base_url: https://api.cerebras.ai/v1
+  model_list:
+
+  - model_name: glm
+    model_id: zai-glm-4.7
+    context_limit: 131072
+    max_tokens: 12800
+    cost: {input: 2.25, output: 2.75}
+
+
 - provider_name: claude-max
   protocol: claude_oauth
   disabled: true

klaude_code/core/agent_profile.py

@@ -132,7 +132,7 @@ def load_system_prompt(
 
     # For codex_oauth protocol, use dynamic prompts from GitHub (no additions).
     if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
-        from klaude_code.llm.codex.prompt_sync import get_codex_instructions
+        from klaude_code.llm.openai_codex.prompt_sync import get_codex_instructions
 
         return get_codex_instructions(model_name)
 
@@ -176,8 +176,6 @@ def load_agent_tools(
     # Main agent tools
     if "gpt-5" in model_name:
         tool_names: list[str] = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
-    elif "gemini-3" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
@@ -189,8 +187,7 @@ def load_agent_tools(
     else:
         tool_names.append(tools.IMAGE_GEN)
 
-    tool_names.extend([tools.MERMAID])
-    # tool_names.extend([tools.MEMORY])
+    tool_names.append(tools.MERMAID)
     return get_tool_schemas(tool_names)
 
 

klaude_code/core/task.py

@@ -210,7 +210,7 @@ class TaskExecutor:
             accumulated = self._metadata_accumulator.get_partial_item(task_duration_s)
             if accumulated is not None:
                 session_id = self._context.session_ctx.session_id
-                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id, cancelled=True))
+                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id))
                 self._context.session_ctx.append_history([accumulated])
 
         return ui_events

klaude_code/core/tool/file/read_tool.py

@@ -22,7 +22,7 @@ from klaude_code.core.tool.file._utils import file_exists, is_directory
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, message, model, tools
-from klaude_code.protocol.model import ImageUIExtra
+from klaude_code.protocol.model import ImageUIExtra, ReadPreviewLine, ReadPreviewUIExtra
 
 _IMAGE_MIME_TYPES: dict[str, str] = {
     ".png": "image/png",
@@ -346,4 +346,15 @@ class ReadTool(ToolABC):
         read_result_str = "\n".join(lines_out)
         _track_file_access(context.file_tracker, file_path, content_sha256=read_result.content_sha256)
 
-        return message.ToolResultMessage(status="success", output_text=read_result_str)
+        # When offset > 1, show a preview of the first 5 lines in UI
+        ui_extra = None
+        if args.offset is not None and args.offset > 1:
+            preview_count = 5
+            preview_lines = [
+                ReadPreviewLine(line_no=line_no, content=content)
+                for line_no, content in read_result.selected_lines[:preview_count]
+            ]
+            remaining = len(read_result.selected_lines) - len(preview_lines)
+            ui_extra = ReadPreviewUIExtra(lines=preview_lines, remaining_lines=remaining)
+
+        return message.ToolResultMessage(status="success", output_text=read_result_str, ui_extra=ui_extra)

klaude_code/core/tool/shell/bash_tool.py

@@ -342,7 +342,7 @@ class BashTool(ToolABC):
                 if not combined:
                     combined = f"Command exited with code {rc}"
                 return message.ToolResultMessage(
-                    status="error",
+                    status="success",
                     # Preserve leading whitespace; only trim trailing newlines.
                     output_text=combined.rstrip("\n"),
                 )

klaude_code/llm/bedrock_anthropic/__init__.py

@@ -0,0 +1,3 @@
+from klaude_code.llm.bedrock_anthropic.client import BedrockClient
+
+__all__ = ["BedrockClient"]

klaude_code/llm/input_common.py

@@ -149,6 +149,14 @@ def build_assistant_common_fields(
             }
             for tc in tool_calls
         ]
+
+    thinking_parts = [part for part in msg.parts if isinstance(part, message.ThinkingTextPart)]
+    if thinking_parts:
+        thinking_text = "".join(part.text for part in thinking_parts)
+        reasoning_field = next((p.reasoning_field for p in thinking_parts if p.reasoning_field), None)
+        if thinking_text and reasoning_field:
+            result[reasoning_field] = thinking_text
+
     return result
 
 
@@ -185,4 +193,14 @@ def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter
         param.verbosity = config.verbosity
     if param.thinking is None:
         param.thinking = config.thinking
+    if param.modalities is None:
+        param.modalities = config.modalities
+    if param.image_config is None:
+        param.image_config = config.image_config
+    elif config.image_config is not None:
+        # Merge field-level: param overrides config defaults
+        if param.image_config.aspect_ratio is None:
+            param.image_config.aspect_ratio = config.image_config.aspect_ratio
+        if param.image_config.image_size is None:
+            param.image_config.image_size = config.image_config.image_size
     return param

klaude_code/llm/{codex → openai_codex}/__init__.py

@@ -1,5 +1,5 @@
 """Codex LLM client using ChatGPT subscription."""
 
-from klaude_code.llm.codex.client import CodexClient
+from klaude_code.llm.openai_codex.client import CodexClient
 
 __all__ = ["CodexClient"]

klaude_code/llm/{codex → openai_codex}/client.py

@@ -20,9 +20,9 @@ from klaude_code.const import (
 )
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_responses.client import ResponsesLLMStream
+from klaude_code.llm.openai_responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.registry import register
-from klaude_code.llm.responses.client import ResponsesLLMStream
-from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.usage import MetadataTracker, error_llm_stream
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param
@@ -164,7 +164,7 @@ def _is_invalid_instruction_error(e: Exception) -> bool:
 
 def _invalidate_prompt_cache_for_model(model_id: str) -> None:
     """Invalidate the cached prompt for a model to force refresh."""
-    from klaude_code.llm.codex.prompt_sync import invalidate_cache
+    from klaude_code.llm.openai_codex.prompt_sync import invalidate_cache
 
     log_debug(
         f"Invalidating prompt cache for model {model_id} due to invalid instruction error",

klaude_code/llm/openai_compatible/client.py

@@ -39,9 +39,11 @@ def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreatePa
         "max_tokens": param.max_tokens,
         "tools": tools,
         "reasoning_effort": param.thinking.reasoning_effort if param.thinking else None,
-        "verbosity": param.verbosity,
     }
 
+    if param.verbosity:
+        payload["verbosity"] = param.verbosity
+
     return payload, extra_body
 
 

klaude_code/llm/openai_compatible/stream.py

@@ -76,9 +76,11 @@ class StreamStateManager:
         """Set the response ID once received from the stream."""
         self.response_id = response_id
 
-    def append_thinking_text(self, text: str) -> None:
+    def append_thinking_text(self, text: str, *, reasoning_field: str | None = None) -> None:
         """Append thinking text, merging with the previous ThinkingTextPart when possible."""
-        append_thinking_text_part(self.assistant_parts, text, model_id=self.param_model)
+        append_thinking_text_part(
+            self.assistant_parts, text, model_id=self.param_model, reasoning_field=reasoning_field
+        )
 
     def append_text(self, text: str) -> None:
         """Append assistant text, merging with the previous TextPart when possible."""
@@ -150,6 +152,7 @@ class ReasoningDeltaResult:
 
     handled: bool
     outputs: list[str | message.Part]
+    reasoning_field: str | None = None  # Original field name: reasoning_content, reasoning, reasoning_text
 
 
 class ReasoningHandlerABC(ABC):
@@ -168,8 +171,11 @@ class ReasoningHandlerABC(ABC):
         """Flush buffered reasoning content (usually at stage transition/finalize)."""
 
 
+REASONING_FIELDS = ("reasoning_content", "reasoning", "reasoning_text")
+
+
 class DefaultReasoningHandler(ReasoningHandlerABC):
-    """Handles OpenAI-compatible reasoning fields (reasoning_content / reasoning)."""
+    """Handles OpenAI-compatible reasoning fields (reasoning_content / reasoning / reasoning_text)."""
 
     def __init__(
         self,
@@ -179,16 +185,20 @@ class DefaultReasoningHandler(ReasoningHandlerABC):
     ) -> None:
         self._param_model = param_model
         self._response_id = response_id
+        self._reasoning_field: str | None = None
 
     def set_response_id(self, response_id: str | None) -> None:
         self._response_id = response_id
 
     def on_delta(self, delta: object) -> ReasoningDeltaResult:
-        reasoning_content = getattr(delta, "reasoning_content", None) or getattr(delta, "reasoning", None) or ""
-        if not reasoning_content:
-            return ReasoningDeltaResult(handled=False, outputs=[])
-        text = str(reasoning_content)
-        return ReasoningDeltaResult(handled=True, outputs=[text])
+        for field_name in REASONING_FIELDS:
+            content = getattr(delta, field_name, None)
+            if content:
+                if self._reasoning_field is None:
+                    self._reasoning_field = field_name
+                text = str(content)
+                return ReasoningDeltaResult(handled=True, outputs=[text], reasoning_field=self._reasoning_field)
+        return ReasoningDeltaResult(handled=False, outputs=[])
 
     def flush(self) -> list[message.Part]:
         return []
@@ -282,7 +292,7 @@ async def parse_chat_completions_stream(
                         if not output:
                             continue
                         metadata_tracker.record_token()
-                        state.append_thinking_text(output)
+                        state.append_thinking_text(output, reasoning_field=reasoning_result.reasoning_field)
                         yield message.ThinkingTextDelta(content=output, response_id=state.response_id)
                     else:
                         state.assistant_parts.append(output)

klaude_code/llm/{responses → openai_responses}/client.py

@@ -11,8 +11,8 @@ from openai.types.responses.response_create_params import ResponseCreateParamsSt
 from klaude_code.const import LLM_HTTP_TIMEOUT_CONNECT, LLM_HTTP_TIMEOUT_READ, LLM_HTTP_TIMEOUT_TOTAL
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.registry import register
-from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.stream_parts import (
     append_text_part,
     append_thinking_text_part,

klaude_code/llm/registry.py

@@ -15,11 +15,11 @@ _REGISTRY: dict[llm_param.LLMClientProtocol, type["LLMClientABC"]] = {}
 _PROTOCOL_MODULES: dict[llm_param.LLMClientProtocol, str] = {
     llm_param.LLMClientProtocol.ANTHROPIC: "klaude_code.llm.anthropic",
     llm_param.LLMClientProtocol.CLAUDE_OAUTH: "klaude_code.llm.claude",
-    llm_param.LLMClientProtocol.BEDROCK: "klaude_code.llm.bedrock",
-    llm_param.LLMClientProtocol.CODEX_OAUTH: "klaude_code.llm.codex",
+    llm_param.LLMClientProtocol.BEDROCK: "klaude_code.llm.bedrock_anthropic",
+    llm_param.LLMClientProtocol.CODEX_OAUTH: "klaude_code.llm.openai_codex",
     llm_param.LLMClientProtocol.OPENAI: "klaude_code.llm.openai_compatible",
     llm_param.LLMClientProtocol.OPENROUTER: "klaude_code.llm.openrouter",
-    llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.responses",
+    llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.openai_responses",
     llm_param.LLMClientProtocol.GOOGLE: "klaude_code.llm.google",
     llm_param.LLMClientProtocol.ANTIGRAVITY: "klaude_code.llm.antigravity",
 }

klaude_code/llm/stream_parts.py

@@ -24,6 +24,7 @@ def append_thinking_text_part(
     text: str,
     *,
     model_id: str,
+    reasoning_field: str | None = None,
     force_new: bool = False,
 ) -> int | None:
     if not text:
@@ -35,10 +36,11 @@ def append_thinking_text_part(
             parts[-1] = message.ThinkingTextPart(
                 text=last.text + text,
                 model_id=model_id,
+                reasoning_field=reasoning_field or last.reasoning_field,
             )
             return len(parts) - 1
 
-    parts.append(message.ThinkingTextPart(text=text, model_id=model_id))
+    parts.append(message.ThinkingTextPart(text=text, model_id=model_id, reasoning_field=reasoning_field))
     return len(parts) - 1
 
 

klaude_code/llm/usage.py

@@ -28,7 +28,7 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     usage.output_cost = (usage.output_tokens / 1_000_000) * cost_config.output
 
     # Cache read cost
-    usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * cost_config.cache_read
+    usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * (cost_config.cache_read or cost_config.input)
 
     # Image generation cost
     usage.image_cost = (usage.image_tokens / 1_000_000) * cost_config.image

klaude_code/protocol/events.py

@@ -119,7 +119,6 @@ class UsageEvent(ResponseEvent):
 
 class TaskMetadataEvent(Event):
     metadata: model.TaskMetadataItem
-    cancelled: bool = False
 
 
 class ThinkingStartEvent(ResponseEvent):

klaude_code/protocol/message.py

@@ -112,6 +112,7 @@ class ThinkingTextPart(BaseModel):
     id: str | None = None
     text: str
     model_id: str | None = None
+    reasoning_field: str | None = None  # Original field name: reasoning_content, reasoning, reasoning_text
 
 
 class ThinkingSignaturePart(BaseModel):

klaude_code/protocol/model.py

@@ -228,6 +228,17 @@ class MarkdownDocUIExtra(BaseModel):
     content: str
 
 
+class ReadPreviewLine(BaseModel):
+    line_no: int
+    content: str
+
+
+class ReadPreviewUIExtra(BaseModel):
+    type: Literal["read_preview"] = "read_preview"
+    lines: list[ReadPreviewLine]
+    remaining_lines: int  # lines not shown in preview
+
+
 class SessionStatusUIExtra(BaseModel):
     type: Literal["session_status"] = "session_status"
     usage: "Usage"
@@ -243,6 +254,7 @@ MultiUIExtraItem = (
     | ImageUIExtra
     | MarkdownDocUIExtra
     | SessionStatusUIExtra
+    | ReadPreviewUIExtra
 )
 
 
@@ -265,7 +277,8 @@ ToolResultUIExtra = Annotated[
     | ImageUIExtra
     | MarkdownDocUIExtra
     | SessionStatusUIExtra
-    | MultiUIExtra,
+    | MultiUIExtra
+    | ReadPreviewUIExtra,
     Field(discriminator="type"),
 ]
 

klaude_code/session/session.py

@@ -316,10 +316,15 @@ class Session(BaseModel):
         prev_item: message.HistoryEvent | None = None
         last_assistant_content: str = ""
         report_back_result: str | None = None
+        pending_tool_calls: dict[str, events.ToolCallEvent] = {}
         history = self.conversation_history
         history_len = len(history)
         yield events.TaskStartEvent(session_id=self.id, sub_agent_state=self.sub_agent_state)
         for idx, it in enumerate(history):
+            # Flush pending tool calls if current item won't consume them
+            if pending_tool_calls and not isinstance(it, message.ToolResultMessage):
+                yield from pending_tool_calls.values()
+                pending_tool_calls.clear()
             if self.need_turn_start(prev_item, it):
                 yield events.TurnStartEvent(session_id=self.id)
             match it:
@@ -331,6 +336,7 @@ class Session(BaseModel):
                     # Reconstruct streaming boundaries from saved parts.
                     # This allows replay to reuse the same TUI state machine as live events.
                     thinking_open = False
+                    thinking_had_content = False
                     assistant_open = False
 
                     for part in am.parts:
@@ -342,15 +348,23 @@ class Session(BaseModel):
                                 thinking_open = True
                                 yield events.ThinkingStartEvent(response_id=am.response_id, session_id=self.id)
                             if part.text:
+                                if thinking_had_content:
+                                    yield events.ThinkingDeltaEvent(
+                                        content="  \n  \n",
+                                        response_id=am.response_id,
+                                        session_id=self.id,
+                                    )
                                 yield events.ThinkingDeltaEvent(
                                     content=part.text,
                                     response_id=am.response_id,
                                     session_id=self.id,
                                 )
+                                thinking_had_content = True
                             continue
 
                         if thinking_open:
                             thinking_open = False
+                            thinking_had_content = False
                             yield events.ThinkingEndEvent(response_id=am.response_id, session_id=self.id)
 
                         if isinstance(part, message.TextPart):
@@ -380,7 +394,7 @@ class Session(BaseModel):
                             continue
                         if part.tool_name == tools.REPORT_BACK:
                             report_back_result = part.arguments_json
-                        yield events.ToolCallEvent(
+                        pending_tool_calls[part.call_id] = events.ToolCallEvent(
                             tool_call_id=part.call_id,
                             tool_name=part.tool_name,
                             arguments=part.arguments_json,
@@ -390,6 +404,8 @@ class Session(BaseModel):
                     if am.stop_reason == "aborted":
                         yield events.InterruptEvent(session_id=self.id)
                 case message.ToolResultMessage() as tr:
+                    if tr.call_id in pending_tool_calls:
+                        yield pending_tool_calls.pop(tr.call_id)
                     status = "success" if tr.status == "success" else "error"
                     # Check if this is the last tool result in the current turn
                     next_item = history[idx + 1] if idx + 1 < history_len else None
@@ -437,6 +453,11 @@ class Session(BaseModel):
                     pass
             prev_item = it
 
+        # Flush any remaining pending tool calls (e.g., from aborted or incomplete sessions)
+        if pending_tool_calls:
+            yield from pending_tool_calls.values()
+            pending_tool_calls.clear()
+
         has_structured_output = report_back_result is not None
         task_result = report_back_result if has_structured_output else last_assistant_content
 

klaude_code/tui/components/bash_syntax.py

@@ -187,6 +187,10 @@ def highlight_bash_command(command: str) -> Text:
                 expect_subcommand = False
         elif token_type in (Token.Text.Whitespace,):
             result.append(token_value)
+            # Newline starts a new command context (like ; or &&)
+            if "\n" in token_value:
+                expect_command = True
+                expect_subcommand = False
         elif token_type == Token.Name.Builtin:
             # Built-in commands are always commands
             result.append(token_value, style=ThemeKey.BASH_COMMAND)