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

klaude_code/core/executor.py

@@ -18,9 +18,11 @@ from klaude_code.config import load_config
 from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
 from klaude_code.core.agent import Agent
 from klaude_code.core.agent_profile import DefaultModelProfileProvider, ModelProfileProvider
+from klaude_code.core.bash_mode import run_bash_command
 from klaude_code.core.compaction import CompactionReason, run_compaction
 from klaude_code.core.loaded_skills import get_loaded_skill_names_by_location
 from klaude_code.core.manager import LLMClients, SubAgentManager
+from klaude_code.core.memory import get_existing_memory_paths_by_location
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import commands, events, message, model, op
@@ -134,18 +136,19 @@ class AgentRuntime:
             compact_llm_client=self._llm_clients.compact,
         )
 
-        async for evt in agent.replay_history():
-            await self._emit_event(evt)
-
         await self._emit_event(
             events.WelcomeEvent(
                 session_id=session.id,
                 work_dir=str(session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
                 loaded_skills=get_loaded_skill_names_by_location(),
+                loaded_memories=get_existing_memory_paths_by_location(work_dir=session.work_dir),
             )
         )
 
+        async for evt in agent.replay_history():
+            await self._emit_event(evt)
+
         self._agent = agent
         log_debug(
             f"Initialized agent for session: {session.id}",
@@ -179,6 +182,23 @@ class AgentRuntime:
         )
         self._task_manager.register(operation.id, task, operation.session_id)
 
+    async def run_bash(self, operation: op.RunBashOperation) -> None:
+        agent = await self.ensure_agent(operation.session_id)
+
+        existing_active = self._task_manager.get(operation.id)
+        if existing_active is not None and not existing_active.task.done():
+            raise RuntimeError(f"Active task already registered for operation {operation.id}")
+
+        task: asyncio.Task[None] = asyncio.create_task(
+            self._run_bash_task(
+                session=agent.session,
+                command=operation.command,
+                task_id=operation.id,
+                session_id=operation.session_id,
+            )
+        )
+        self._task_manager.register(operation.id, task, operation.session_id)
+
     async def continue_agent(self, operation: op.ContinueAgentOperation) -> None:
         """Continue agent execution without adding a new user message."""
         agent = await self.ensure_agent(operation.session_id)
@@ -230,6 +250,7 @@ class AgentRuntime:
                 work_dir=str(agent.session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
                 loaded_skills=get_loaded_skill_names_by_location(),
+                loaded_memories=get_existing_memory_paths_by_location(work_dir=agent.session.work_dir),
             )
         )
 
@@ -249,18 +270,19 @@ class AgentRuntime:
             compact_llm_client=self._llm_clients.compact,
         )
 
-        async for evt in agent.replay_history():
-            await self._emit_event(evt)
-
         await self._emit_event(
             events.WelcomeEvent(
                 session_id=target_session.id,
                 work_dir=str(target_session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
                 loaded_skills=get_loaded_skill_names_by_location(),
+                loaded_memories=get_existing_memory_paths_by_location(work_dir=target_session.work_dir),
             )
         )
 
+        async for evt in agent.replay_history():
+            await self._emit_event(evt)
+
         self._agent = agent
         log_debug(
             f"Resumed session: {target_session.id}",
@@ -359,6 +381,14 @@ class AgentRuntime:
                 debug_type=DebugType.EXECUTION,
             )
 
+    async def _run_bash_task(self, *, session: Session, command: str, task_id: str, session_id: str) -> None:
+        await run_bash_command(
+            emit_event=self._emit_event,
+            session=session,
+            session_id=session_id,
+            command=command,
+        )
+
     async def _run_compaction_task(
         self,
         agent: Agent,
@@ -467,7 +497,7 @@ class ModelSwitcher:
             config.main_model = model_name
             await config.save()
 
-        return llm_config, llm_client.model_name
+        return llm_config, model_name
 
     def change_thinking(self, agent: Agent, *, thinking: Thinking) -> Thinking | None:
         """Apply thinking configuration to the agent's active LLM config and persisted session."""
@@ -540,6 +570,9 @@ class ExecutorContext:
     async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
         await self._agent_runtime.run_agent(operation)
 
+    async def handle_run_bash(self, operation: op.RunBashOperation) -> None:
+        await self._agent_runtime.run_bash(operation)
+
     async def handle_continue_agent(self, operation: op.ContinueAgentOperation) -> None:
         await self._agent_runtime.continue_agent(operation)
 

klaude_code/core/manager/llm_clients.py

@@ -19,6 +19,7 @@ class LLMClients:
     """Container for LLM clients used by main agent and sub-agents."""
 
     main: LLMClientABC
+    main_model_alias: str = ""
     sub_clients: dict[SubAgentType, LLMClientABC] = dataclass_field(default_factory=_default_sub_clients)
     compact: LLMClientABC | None = None
 

klaude_code/core/manager/llm_clients_builder.py

@@ -53,7 +53,7 @@ def build_llm_clients(
         compact_client = create_llm_client(compact_llm_config)
 
     if skip_sub_agents:
-        return LLMClients(main=main_client, compact=compact_client)
+        return LLMClients(main=main_client, main_model_alias=model_name, compact=compact_client)
 
     helper = SubAgentModelHelper(config)
     sub_agent_configs = helper.build_sub_agent_client_configs()
@@ -63,4 +63,4 @@ def build_llm_clients(
         sub_llm_config = config.get_model_config(sub_model_name)
         sub_clients[sub_agent_type] = create_llm_client(sub_llm_config)
 
-    return LLMClients(main=main_client, sub_clients=sub_clients, compact=compact_client)
+    return LLMClients(main=main_client, main_model_alias=model_name, sub_clients=sub_clients, compact=compact_client)

klaude_code/core/memory.py

@@ -0,0 +1,140 @@
+"""Memory file loading and management.
+
+This module handles CLAUDE.md and AGENTS.md memory files - discovery, loading,
+and providing summaries for UI display.
+"""
+
+from collections.abc import Callable
+from pathlib import Path
+
+from pydantic import BaseModel
+
+MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
+
+
+class Memory(BaseModel):
+    """Represents a loaded memory file."""
+
+    path: str
+    instruction: str
+    content: str
+
+
+def get_memory_paths(*, work_dir: Path) -> list[tuple[Path, str]]:
+    """Return all possible memory file paths with their descriptions."""
+    user_dirs = [Path.home() / ".claude", Path.home() / ".codex"]
+    project_dirs = [work_dir, work_dir / ".claude"]
+
+    paths: list[tuple[Path, str]] = []
+    for d in user_dirs:
+        for fname in MEMORY_FILE_NAMES:
+            paths.append((d / fname, "user's private global instructions for all projects"))
+    for d in project_dirs:
+        for fname in MEMORY_FILE_NAMES:
+            paths.append((d / fname, "project instructions, checked into the codebase"))
+    return paths
+
+
+def get_existing_memory_files(*, work_dir: Path) -> dict[str, list[str]]:
+    """Return existing memory file paths grouped by location (user/project)."""
+    result: dict[str, list[str]] = {"user": [], "project": []}
+    work_dir = work_dir.resolve()
+
+    for memory_path, _instruction in get_memory_paths(work_dir=work_dir):
+        if memory_path.exists() and memory_path.is_file():
+            path_str = str(memory_path)
+            resolved = memory_path.resolve()
+            try:
+                resolved.relative_to(work_dir)
+                result["project"].append(path_str)
+            except ValueError:
+                result["user"].append(path_str)
+
+    return result
+
+
+def get_existing_memory_paths_by_location(*, work_dir: Path) -> dict[str, list[str]]:
+    """Return existing memory file paths grouped by location for WelcomeEvent."""
+    result = get_existing_memory_files(work_dir=work_dir)
+    if not result.get("user") and not result.get("project"):
+        return {}
+    return result
+
+
+def format_memory_content(memory: Memory) -> str:
+    """Format a single memory file content for display."""
+    return f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}"
+
+
+def format_memories_reminder(memories: list[Memory], include_header: bool = True) -> str:
+    """Format memory files into a system reminder string."""
+    memories_str = "\n\n".join(format_memory_content(m) for m in memories)
+    if include_header:
+        return f"""<system-reminder>
+Loaded memory files. Follow these instructions. Do not mention them to the user unless explicitly asked.
+
+{memories_str}
+</system-reminder>"""
+    return f"<system-reminder>{memories_str}\n</system-reminder>"
+
+
+def discover_memory_files_near_paths(
+    paths: list[str],
+    *,
+    work_dir: Path,
+    is_memory_loaded: Callable[[str], bool],
+    mark_memory_loaded: Callable[[str], None],
+) -> list[Memory]:
+    """Discover and load CLAUDE.md/AGENTS.md from directories containing accessed files.
+
+    Args:
+        paths: List of file paths that have been accessed.
+        is_memory_loaded: Callback to check if a memory file is already loaded.
+        mark_memory_loaded: Callback to mark a memory file as loaded.
+
+    Returns:
+        List of newly discovered Memory objects.
+    """
+    memories: list[Memory] = []
+    work_dir = work_dir.resolve()
+    seen_memory_files: set[str] = set()
+
+    for p_str in paths:
+        p = Path(p_str)
+        full = (work_dir / p).resolve() if not p.is_absolute() else p.resolve()
+        try:
+            _ = full.relative_to(work_dir)
+        except ValueError:
+            continue
+
+        deepest_dir = full if full.is_dir() else full.parent
+
+        try:
+            rel_parts = deepest_dir.relative_to(work_dir).parts
+        except ValueError:
+            continue
+
+        current_dir = work_dir
+        for part in rel_parts:
+            current_dir = current_dir / part
+            for fname in MEMORY_FILE_NAMES:
+                mem_path = current_dir / fname
+                mem_path_str = str(mem_path)
+                if mem_path_str in seen_memory_files or is_memory_loaded(mem_path_str):
+                    continue
+                if mem_path.exists() and mem_path.is_file():
+                    try:
+                        text = mem_path.read_text(encoding="utf-8", errors="replace")
+                    except (PermissionError, UnicodeDecodeError, OSError):
+                        continue
+                    mark_memory_loaded(mem_path_str)
+                    seen_memory_files.add(mem_path_str)
+                    memories.append(
+                        Memory(
+                            path=mem_path_str,
+                            instruction="project instructions, discovered near last accessed path",
+                            content=text,
+                        )
+                    )
+
+    return memories

klaude_code/core/reminders.py

@@ -4,9 +4,13 @@ import shlex
 from dataclasses import dataclass
 from pathlib import Path
 
-from pydantic import BaseModel
-
-from klaude_code.const import MEMORY_FILE_NAMES, REMINDER_COOLDOWN_TURNS, TODO_REMINDER_TOOL_CALL_THRESHOLD
+from klaude_code.const import REMINDER_COOLDOWN_TURNS, TODO_REMINDER_TOOL_CALL_THRESHOLD
+from klaude_code.core.memory import (
+    Memory,
+    discover_memory_files_near_paths,
+    format_memories_reminder,
+    get_memory_paths,
+)
 from klaude_code.core.tool import BashTool, ReadTool, build_todo_context
 from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.file._utils import hash_text_sha256
@@ -382,28 +386,6 @@ def _compute_file_content_sha256(path: str) -> str | None:
         return None
 
 
-def get_memory_paths() -> list[tuple[Path, str]]:
-    return [
-        (
-            Path.home() / ".claude" / "CLAUDE.md",
-            "user's private global instructions for all projects",
-        ),
-        (
-            Path.home() / ".codex" / "AGENTS.md",
-            "user's private global instructions for all projects",
-        ),
-        (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / ".claude" / "CLAUDE.md", "project instructions, checked into the codebase"),
-    ]
-
-
-class Memory(BaseModel):
-    path: str
-    instruction: str
-    content: str
-
-
 def get_last_user_message_image_paths(session: Session) -> list[str]:
     """Get image file paths from the last user message in conversation history."""
     for item in reversed(session.conversation_history):
@@ -502,7 +484,7 @@ def _mark_memory_loaded(session: Session, path: str) -> None:
 
 async def memory_reminder(session: Session) -> message.DeveloperMessage | None:
     """CLAUDE.md AGENTS.md"""
-    memory_paths = get_memory_paths()
+    memory_paths = get_memory_paths(work_dir=session.work_dir)
     memories: list[Memory] = []
     for memory_path, instruction in memory_paths:
         path_str = str(memory_path)
@@ -514,21 +496,12 @@ async def memory_reminder(session: Session) -> message.DeveloperMessage | None:
             except (PermissionError, UnicodeDecodeError, OSError):
                 continue
     if len(memories) > 0:
-        memories_str = "\n\n".join(
-            [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
-        )
         loaded_files = [
             model.MemoryFileLoaded(path=memory.path, mentioned_patterns=_extract_at_patterns(memory.content))
             for memory in memories
         ]
         return message.DeveloperMessage(
-            parts=message.text_parts_from_str(
-                f"""<system-reminder>
-Loaded memory files. Follow these instructions. Do not mention them to the user unless explicitly asked.
-
-{memories_str}
-</system-reminder>"""
-            ),
+            parts=message.text_parts_from_str(format_memories_reminder(memories, include_header=True)),
             ui_extra=model.DeveloperUIExtra(items=[model.MemoryLoadedUIItem(files=loaded_files)]),
         )
     return None
@@ -546,68 +519,23 @@ async def last_path_memory_reminder(
         return None
 
     paths = list(session.file_tracker.keys())
-    memories: list[Memory] = []
-
-    cwd = Path.cwd().resolve()
-    seen_memory_files: set[str] = set()
-
-    for p_str in paths:
-        p = Path(p_str)
-        full = (cwd / p).resolve() if not p.is_absolute() else p.resolve()
-        try:
-            _ = full.relative_to(cwd)
-        except ValueError:
-            # Not under cwd; skip
-            continue
-
-        # Determine the deepest directory to scan (file parent or directory itself)
-        deepest_dir = full if full.is_dir() else full.parent
-
-        # Iterate each directory level from cwd to deepest_dir
-        try:
-            rel_parts = deepest_dir.relative_to(cwd).parts
-        except ValueError:
-            # Shouldn't happen due to check above, but guard anyway
-            continue
-
-        current_dir = cwd
-        for part in rel_parts:
-            current_dir = current_dir / part
-            for fname in MEMORY_FILE_NAMES:
-                mem_path = current_dir / fname
-                mem_path_str = str(mem_path)
-                if mem_path_str in seen_memory_files or _is_memory_loaded(session, mem_path_str):
-                    continue
-                if mem_path.exists() and mem_path.is_file():
-                    try:
-                        text = mem_path.read_text(encoding="utf-8", errors="replace")
-                    except (PermissionError, UnicodeDecodeError, OSError):
-                        continue
-                    _mark_memory_loaded(session, mem_path_str)
-                    seen_memory_files.add(mem_path_str)
-                    memories.append(
-                        Memory(
-                            path=mem_path_str,
-                            instruction="project instructions, discovered near last accessed path",
-                            content=text,
-                        )
-                    )
+    memories = discover_memory_files_near_paths(
+        paths,
+        work_dir=session.work_dir,
+        is_memory_loaded=lambda p: _is_memory_loaded(session, p),
+        mark_memory_loaded=lambda p: _mark_memory_loaded(session, p),
+    )
 
     if len(memories) > 0:
-        memories_str = "\n\n".join(
-            [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
-        )
         loaded_files = [
             model.MemoryFileLoaded(path=memory.path, mentioned_patterns=_extract_at_patterns(memory.content))
             for memory in memories
         ]
         return message.DeveloperMessage(
-            parts=message.text_parts_from_str(
-                f"""<system-reminder>{memories_str}
-</system-reminder>"""
-            ),
+            parts=message.text_parts_from_str(format_memories_reminder(memories, include_header=False)),
             ui_extra=model.DeveloperUIExtra(items=[model.MemoryLoadedUIItem(files=loaded_files)]),
         )
+    return None
 
 
 ALL_REMINDERS = [

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/core/turn.py

@@ -194,11 +194,17 @@ class TurnExecutor:
                 and self._turn_result.assistant_message is not None
                 and self._turn_result.assistant_message.parts
             ):
-                session_ctx.append_history([self._turn_result.assistant_message])
-                # Add continuation prompt to avoid Anthropic thinking block requirement
-                session_ctx.append_history(
-                    [message.UserMessage(parts=[message.TextPart(text="<system>continue</system>")])]
+                # Discard partial message if it only contains thinking parts
+                has_non_thinking = any(
+                    not isinstance(part, message.ThinkingTextPart)
+                    for part in self._turn_result.assistant_message.parts
                 )
+                if has_non_thinking:
+                    session_ctx.append_history([self._turn_result.assistant_message])
+                    # Add continuation prompt to avoid Anthropic thinking block requirement
+                    session_ctx.append_history(
+                        [message.UserMessage(parts=[message.TextPart(text="<system>continue</system>")])]
+                    )
             yield events.TurnEndEvent(session_id=session_ctx.session_id)
             raise TurnError(self._turn_result.stream_error.error)
 

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,