klaude-code 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

klaude_code/core/task.py

@@ -25,28 +25,30 @@ class MetadataAccumulator:
     """
 
     def __init__(self, model_name: str) -> None:
-        self._accumulated = model.ResponseMetadataItem(model_name=model_name)
+        self._main = model.TaskMetadata(model_name=model_name)
+        self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
 
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
-        accumulated = self._accumulated
+        main = self._main
         usage = turn_metadata.usage
 
         if usage is not None:
-            if accumulated.usage is None:
-                accumulated.usage = model.Usage()
-            acc_usage = accumulated.usage
+            if main.usage is None:
+                main.usage = model.Usage()
+            acc_usage = main.usage
             acc_usage.input_tokens += usage.input_tokens
             acc_usage.cached_tokens += usage.cached_tokens
             acc_usage.reasoning_tokens += usage.reasoning_tokens
             acc_usage.output_tokens += usage.output_tokens
-            acc_usage.total_tokens += usage.total_tokens
             acc_usage.currency = usage.currency
 
-            if usage.context_usage_percent is not None:
-                acc_usage.context_usage_percent = usage.context_usage_percent
+            if usage.context_window_size is not None:
+                acc_usage.context_window_size = usage.context_window_size
+            if usage.context_limit is not None:
+                acc_usage.context_limit = usage.context_limit
 
             if usage.first_token_latency_ms is not None:
                 if acc_usage.first_token_latency_ms is None:
@@ -63,51 +65,56 @@ class MetadataAccumulator:
                     self._throughput_weighted_sum += usage.throughput_tps * current_output
                     self._throughput_tracked_tokens += current_output
 
-            # Accumulate costs
             if usage.input_cost is not None:
                 acc_usage.input_cost = (acc_usage.input_cost or 0.0) + usage.input_cost
             if usage.output_cost is not None:
                 acc_usage.output_cost = (acc_usage.output_cost or 0.0) + usage.output_cost
             if usage.cache_read_cost is not None:
                 acc_usage.cache_read_cost = (acc_usage.cache_read_cost or 0.0) + usage.cache_read_cost
-            if usage.total_cost is not None:
-                acc_usage.total_cost = (acc_usage.total_cost or 0.0) + usage.total_cost
 
         if turn_metadata.provider is not None:
-            accumulated.provider = turn_metadata.provider
+            main.provider = turn_metadata.provider
         if turn_metadata.model_name:
-            accumulated.model_name = turn_metadata.model_name
-        if turn_metadata.response_id:
-            accumulated.response_id = turn_metadata.response_id
-        if turn_metadata.status is not None:
-            accumulated.status = turn_metadata.status
-        if turn_metadata.error_reason is not None:
-            accumulated.error_reason = turn_metadata.error_reason
-
-    def finalize(self, task_duration_s: float) -> model.ResponseMetadataItem:
+            main.model_name = turn_metadata.model_name
+
+    def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
+        """Add sub-agent task metadata to the accumulated state."""
+        self._sub_agent_metadata.append(sub_agent_metadata)
+
+    def finalize(self, task_duration_s: float) -> model.TaskMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""
-        accumulated = self._accumulated
-        if accumulated.usage is not None:
+        main = self._main
+        if main.usage is not None:
             if self._throughput_tracked_tokens > 0:
-                accumulated.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
+                main.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
             else:
-                accumulated.usage.throughput_tps = None
+                main.usage.throughput_tps = None
 
-        accumulated.task_duration_s = task_duration_s
-        return accumulated
+        main.task_duration_s = task_duration_s
+        return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
 
 
 @dataclass
-class TaskExecutionContext:
-    """Execution context required to run a task."""
+class SessionContext:
+    """Shared session-level context for task and turn execution.
+
+    Contains common fields that both TaskExecutionContext and TurnExecutionContext need.
+    """
 
     session_id: str
-    profile: AgentProfile
     get_conversation_history: Callable[[], list[model.ConversationItem]]
     append_history: Callable[[Sequence[model.ConversationItem]], None]
-    tool_registry: dict[str, type[ToolABC]]
     file_tracker: MutableMapping[str, float]
     todo_context: TodoContext
+
+
+@dataclass
+class TaskExecutionContext:
+    """Execution context required to run a task."""
+
+    session_ctx: SessionContext
+    profile: AgentProfile
+    tool_registry: dict[str, type[ToolABC]]
     # For reminder processing - needs access to session
     process_reminder: Callable[[Reminder], AsyncGenerator[events.DeveloperMessageEvent, None]]
     sub_agent_state: model.SubAgentState | None
@@ -139,18 +146,18 @@ class TaskExecutor:
     async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event, None]:
         """Execute the task, yielding events as they occur."""
         ctx = self._context
+        session_ctx = ctx.session_ctx
         self._started_at = time.perf_counter()
 
         yield events.TaskStartEvent(
-            session_id=ctx.session_id,
+            session_id=session_ctx.session_id,
             sub_agent_state=ctx.sub_agent_state,
         )
 
-        ctx.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        session_ctx.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
 
         profile = ctx.profile
         metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
-        last_assistant_message: events.AssistantMessageEvent | None = None
 
         while True:
             # Process reminders at the start of each turn
@@ -159,15 +166,11 @@ class TaskExecutor:
                     yield event
 
             turn_context = TurnExecutionContext(
-                session_id=ctx.session_id,
-                get_conversation_history=ctx.get_conversation_history,
-                append_history=ctx.append_history,
+                session_ctx=session_ctx,
                 llm_client=profile.llm_client,
                 system_prompt=profile.system_prompt,
                 tools=profile.tools,
                 tool_registry=ctx.tool_registry,
-                file_tracker=ctx.file_tracker,
-                todo_context=ctx.todo_context,
             )
 
             turn: TurnExecutor | None = None
@@ -182,11 +185,14 @@ class TaskExecutor:
                     async for turn_event in turn.run():
                         match turn_event:
                             case events.AssistantMessageEvent() as am:
-                                if am.content.strip() != "":
-                                    last_assistant_message = am
                                 yield am
                             case events.ResponseMetadataEvent() as e:
                                 metadata_accumulator.add(e.metadata)
+                            case events.ToolResultEvent() as e:
+                                # Collect sub-agent task metadata from tool results
+                                if e.task_metadata is not None:
+                                    metadata_accumulator.add_sub_agent_metadata(e.task_metadata)
+                                yield turn_event
                             case _:
                                 yield turn_event
 
@@ -223,14 +229,23 @@ class TaskExecutor:
         task_duration_s = time.perf_counter() - self._started_at
         accumulated = metadata_accumulator.finalize(task_duration_s)
 
-        yield events.ResponseMetadataEvent(metadata=accumulated, session_id=ctx.session_id)
-        ctx.append_history([accumulated])
+        yield events.TaskMetadataEvent(metadata=accumulated, session_id=session_ctx.session_id)
+        session_ctx.append_history([accumulated])
         yield events.TaskFinishEvent(
-            session_id=ctx.session_id,
-            task_result=last_assistant_message.content if last_assistant_message else "",
+            session_id=session_ctx.session_id,
+            task_result=_get_last_assistant_message(session_ctx.get_conversation_history()) or "",
         )
 
 
+def _get_last_assistant_message(history: list[model.ConversationItem]) -> str | None:
+    """Return the content of the most recent assistant message in history."""
+
+    for item in reversed(history):
+        if isinstance(item, model.AssistantMessageItem):
+            return item.content or ""
+    return None
+
+
 def _retry_delay_seconds(attempt: int) -> float:
     """Compute exponential backoff delay for the given attempt count."""
     capped_attempt = max(1, attempt)

klaude_code/core/tool/__init__.py

@@ -16,6 +16,7 @@ from .tool_abc import ToolABC
 from .tool_context import (
     TodoContext,
     ToolContextToken,
+    build_todo_context,
     current_run_subtask_callback,
     reset_tool_context,
     set_tool_context_from_session,
@@ -46,6 +47,7 @@ __all__ = [
     "ToolABC",
     # Tool context
     "TodoContext",
+    "build_todo_context",
     "ToolContextToken",
     "current_run_subtask_callback",
     "reset_tool_context",

klaude_code/core/tool/file/apply_patch_tool.py

@@ -26,7 +26,7 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text),
+            ui_extra=model.DiffTextUIExtra(diff_text=diff_text),
         )
 
     @staticmethod

klaude_code/core/tool/file/edit_tool.py

@@ -212,7 +212,7 @@ class EditTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         # Update tracker with new mtime
         if file_tracker is not None:

klaude_code/core/tool/file/multi_edit_tool.py

@@ -183,7 +183,7 @@ class MultiEditTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         # Update tracker
         if file_tracker is not None:

klaude_code/core/tool/file/write_tool.py

@@ -140,7 +140,7 @@ class WriteTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
         return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)

klaude_code/core/tool/memory/memory_tool.py

@@ -100,7 +100,7 @@ def _format_numbered_line(line_no: int, content: str) -> str:
     return f"{line_no:>6}|{content}"
 
 
-def _make_diff_ui_extra(before: str, after: str, path: str) -> model.ToolResultUIExtra:
+def _make_diff_ui_extra(before: str, after: str, path: str) -> model.DiffTextUIExtra:
     diff_lines = list(
         difflib.unified_diff(
             before.splitlines(),
@@ -111,7 +111,7 @@ def _make_diff_ui_extra(before: str, after: str, path: str) -> model.ToolResultU
         )
     )
     diff_text = "\n".join(diff_lines)
-    return model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+    return model.DiffTextUIExtra(diff_text=diff_text)
 
 
 @register(tools.MEMORY)

klaude_code/core/tool/sub_agent_tool.py

@@ -79,5 +79,6 @@ class SubAgentTool(ToolABC):
         return model.ToolResultItem(
             status="success" if not result.error else "error",
             output=result.task_result or "",
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.SESSION_ID, session_id=result.session_id),
+            ui_extra=model.SessionIdUIExtra(session_id=result.session_id),
+            task_metadata=result.task_metadata,
         )

klaude_code/core/tool/todo/todo_write_tool.py

@@ -116,6 +116,6 @@ Your todo list has changed. DO NOT mention this explicitly to the user. Here are
         return model.ToolResultItem(
             status="success",
             output=response,
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            ui_extra=model.TodoListUIExtra(todo_list=ui_extra),
             side_effects=[model.ToolSideEffect.TODO_CHANGE],
         )

klaude_code/core/tool/todo/update_plan_tool.py

@@ -99,6 +99,6 @@ class UpdatePlanTool(ToolABC):
         return model.ToolResultItem(
             status="success",
             output="Plan updated",
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            ui_extra=model.TodoListUIExtra(todo_list=ui_extra),
             side_effects=[model.ToolSideEffect.TODO_CHANGE],
         )

klaude_code/core/tool/tool_context.py

@@ -22,6 +22,19 @@ class TodoContext:
     set_todos: Callable[[list[model.TodoItem]], None]
 
 
+@dataclass
+class SessionTodoStore:
+    """Adapter exposing session todos through an explicit interface."""
+
+    session: Session
+
+    def get(self) -> list[model.TodoItem]:
+        return self.session.todos
+
+    def set(self, todos: list[model.TodoItem]) -> None:
+        self.session.todos = todos
+
+
 @dataclass
 class ToolContextToken:
     """Tokens used to restore tool execution context.
@@ -55,10 +68,7 @@ def set_tool_context_from_session(session: Session) -> ToolContextToken:
     """
 
     file_tracker_token = current_file_tracker_var.set(session.file_tracker)
-    todo_ctx = TodoContext(
-        get_todos=lambda: session.todos,
-        set_todos=lambda todos: setattr(session, "todos", todos),
-    )
+    todo_ctx = build_todo_context(session)
     todo_token = current_todo_context_var.set(todo_ctx)
     return ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
 
@@ -87,6 +97,13 @@ def tool_context(
         reset_tool_context(token)
 
 
+def build_todo_context(session: Session) -> TodoContext:
+    """Create a TodoContext backed by the given session."""
+
+    store = SessionTodoStore(session)
+    return TodoContext(get_todos=store.get, set_todos=store.set)
+
+
 def get_current_file_tracker() -> MutableMapping[str, float] | None:
     """Return the current file tracker mapping for this tool context."""
 

klaude_code/core/tool/tool_runner.py

@@ -34,13 +34,10 @@ async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolA
             truncation_result = truncate_tool_output(tool_result.output, tool_call)
             tool_result.output = truncation_result.output
             if truncation_result.was_truncated and truncation_result.saved_file_path:
-                tool_result.ui_extra = model.ToolResultUIExtra(
-                    type=model.ToolResultUIExtraType.TRUNCATION,
-                    truncation=model.TruncationUIExtra(
-                        saved_file_path=truncation_result.saved_file_path,
-                        original_length=truncation_result.original_length,
-                        truncated_length=truncation_result.truncated_length,
-                    ),
+                tool_result.ui_extra = model.TruncationUIExtra(
+                    saved_file_path=truncation_result.saved_file_path,
+                    original_length=truncation_result.original_length,
+                    truncated_length=truncation_result.truncated_length,
                 )
         return tool_result
     except asyncio.CancelledError:
@@ -244,7 +241,7 @@ class ToolExecutor:
         for side_effect in side_effects:
             if side_effect == model.ToolSideEffect.TODO_CHANGE:
                 todos: list[model.TodoItem] | None = None
-                if tool_result.ui_extra is not None and tool_result.ui_extra.todo_list is not None:
+                if isinstance(tool_result.ui_extra, model.TodoListUIExtra):
                     todos = tool_result.ui_extra.todo_list.todos
                 if todos is not None:
                     side_effect_events.append(ToolExecutionTodoChange(todos=todos))

klaude_code/core/tool/web/mermaid_tool.py

@@ -49,10 +49,7 @@ class MermaidTool(ToolABC):
 
         link = cls._build_link(args.code)
         line_count = cls._count_lines(args.code)
-        ui_extra = model.ToolResultUIExtra(
-            type=model.ToolResultUIExtraType.MERMAID_LINK,
-            mermaid_link=model.MermaidLinkUIExtra(link=link, line_count=line_count),
-        )
+        ui_extra = model.MermaidLinkUIExtra(link=link, line_count=line_count)
         output = f"Mermaid diagram rendered successfully ({line_count} lines)."
         return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
 

klaude_code/core/turn.py

@@ -1,9 +1,14 @@
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, Callable, MutableMapping, Sequence
+from collections.abc import AsyncGenerator
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from klaude_code.core.tool import ToolABC, tool_context
+
+if TYPE_CHECKING:
+    from klaude_code.core.task import SessionContext
 
-from klaude_code.core.tool import TodoContext, ToolABC, tool_context
 from klaude_code.core.tool.tool_runner import (
     ToolExecutionCallStarted,
     ToolExecutionResult,
@@ -26,16 +31,21 @@ class TurnError(Exception):
 class TurnExecutionContext:
     """Execution context required to run a single turn."""
 
-    session_id: str
-    get_conversation_history: Callable[[], list[model.ConversationItem]]
-    append_history: Callable[[Sequence[model.ConversationItem]], None]
+    session_ctx: SessionContext
     llm_client: LLMClientABC
     system_prompt: str | None
     tools: list[llm_param.ToolSchema]
     tool_registry: dict[str, type[ToolABC]]
-    # For tool context
-    file_tracker: MutableMapping[str, float]
-    todo_context: TodoContext
+
+
+@dataclass
+class TurnResult:
+    """Aggregated state produced while executing a turn."""
+
+    reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem]
+    assistant_message: model.AssistantMessageItem | None
+    tool_calls: list[model.ToolCallItem]
+    stream_error: model.StreamErrorItem | None
 
 
 def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEvent) -> list[events.Event]:
@@ -64,6 +74,7 @@ def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEv
                     result=tool_result.output or "",
                     ui_extra=tool_result.ui_extra,
                     status=tool_result.status,
+                    task_metadata=tool_result.task_metadata,
                 )
             )
         case ToolExecutionTodoChange(todos=todos):
@@ -87,18 +98,18 @@ class TurnExecutor:
     def __init__(self, context: TurnExecutionContext) -> None:
         self._context = context
         self._tool_executor: ToolExecutor | None = None
-        self._has_tool_call: bool = False
+        self._turn_result: TurnResult | None = None
 
     @property
     def has_tool_call(self) -> bool:
-        return self._has_tool_call
+        return bool(self._turn_result and self._turn_result.tool_calls)
 
     def cancel(self) -> list[events.Event]:
         """Cancel running tools and return any resulting events."""
         ui_events: list[events.Event] = []
         if self._tool_executor is not None:
             for exec_event in self._tool_executor.cancel():
-                for ui_event in build_events_from_tool_executor_event(self._context.session_id, exec_event):
+                for ui_event in build_events_from_tool_executor_event(self._context.session_ctx.session_id, exec_event):
                     ui_events.append(ui_event)
             self._tool_executor = None
         return ui_events
@@ -110,22 +121,45 @@ class TurnExecutor:
             TurnError: If the turn fails (stream error or non-completed status).
         """
         ctx = self._context
+        session_ctx = ctx.session_ctx
+
+        yield events.TurnStartEvent(session_id=session_ctx.session_id)
+
+        self._turn_result = TurnResult(
+            reasoning_items=[],
+            assistant_message=None,
+            tool_calls=[],
+            stream_error=None,
+        )
+
+        async for event in self._consume_llm_stream(self._turn_result):
+            yield event
+
+        if self._turn_result.stream_error is not None:
+            session_ctx.append_history([self._turn_result.stream_error])
+            yield events.TurnEndEvent(session_id=session_ctx.session_id)
+            raise TurnError(self._turn_result.stream_error.error)
 
-        yield events.TurnStartEvent(session_id=ctx.session_id)
+        self._append_success_history(self._turn_result)
 
-        turn_reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = []
-        turn_assistant_message: model.AssistantMessageItem | None = None
-        turn_tool_calls: list[model.ToolCallItem] = []
-        response_failed = False
-        error_message: str | None = None
+        if self._turn_result.tool_calls:
+            async for ui_event in self._run_tool_executor(self._turn_result.tool_calls):
+                yield ui_event
 
+        yield events.TurnEndEvent(session_id=session_ctx.session_id)
+
+    async def _consume_llm_stream(self, turn_result: TurnResult) -> AsyncGenerator[events.Event, None]:
+        """Stream events from LLM and update turn_result in place."""
+
+        ctx = self._context
+        session_ctx = ctx.session_ctx
         async for response_item in ctx.llm_client.call(
             llm_param.LLMCallParameter(
-                input=ctx.get_conversation_history(),
+                input=session_ctx.get_conversation_history(),
                 system=ctx.system_prompt,
                 tools=ctx.tools,
                 store=False,
-                session_id=ctx.session_id,
+                session_id=session_ctx.session_id,
             )
         ):
             log_debug(
@@ -136,41 +170,36 @@ class TurnExecutor:
             )
             match response_item:
                 case model.StartItem():
-                    pass
+                    continue
                 case model.ReasoningTextItem() as item:
-                    turn_reasoning_items.append(item)
+                    turn_result.reasoning_items.append(item)
                     yield events.ThinkingEvent(
                         content=item.content,
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.ReasoningEncryptedItem() as item:
-                    turn_reasoning_items.append(item)
+                    turn_result.reasoning_items.append(item)
                 case model.AssistantMessageDelta() as item:
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.AssistantMessageItem() as item:
-                    turn_assistant_message = item
+                    turn_result.assistant_message = item
                     yield events.AssistantMessageEvent(
                         content=item.content or "",
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.ResponseMetadataItem() as item:
                     yield events.ResponseMetadataEvent(
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                         metadata=item,
                     )
-                    status = item.status
-                    if status is not None and status != "completed":
-                        response_failed = True
-                        error_message = f"Response status: {status}"
                 case model.StreamErrorItem() as item:
-                    response_failed = True
-                    error_message = item.error
+                    turn_result.stream_error = item
                     log_debug(
                         "[StreamError]",
                         item.error,
@@ -179,42 +208,41 @@ class TurnExecutor:
                     )
                 case model.ToolCallStartItem() as item:
                     yield events.TurnToolCallStartEvent(
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                         response_id=item.response_id,
                         tool_call_id=item.call_id,
                         tool_name=item.name,
                         arguments="",
                     )
                 case model.ToolCallItem() as item:
-                    turn_tool_calls.append(item)
+                    turn_result.tool_calls.append(item)
                 case _:
-                    pass
-
-        if response_failed:
-            yield events.TurnEndEvent(session_id=ctx.session_id)
-            raise TurnError(error_message or "Turn failed")
-
-        # Append to history only on success
-        if turn_reasoning_items:
-            ctx.append_history(turn_reasoning_items)
-        if turn_assistant_message:
-            ctx.append_history([turn_assistant_message])
-        if turn_tool_calls:
-            ctx.append_history(turn_tool_calls)
-            self._has_tool_call = True
-
-        # Execute tools
-        if turn_tool_calls:
-            with tool_context(ctx.file_tracker, ctx.todo_context):
-                executor = ToolExecutor(
-                    registry=ctx.tool_registry,
-                    append_history=ctx.append_history,
-                )
-                self._tool_executor = executor
+                    continue
+
+    def _append_success_history(self, turn_result: TurnResult) -> None:
+        """Persist successful turn artifacts to conversation history."""
+        session_ctx = self._context.session_ctx
+        if turn_result.reasoning_items:
+            session_ctx.append_history(turn_result.reasoning_items)
+        if turn_result.assistant_message:
+            session_ctx.append_history([turn_result.assistant_message])
+        if turn_result.tool_calls:
+            session_ctx.append_history(turn_result.tool_calls)
 
-                async for exec_event in executor.run_tools(turn_tool_calls):
-                    for ui_event in build_events_from_tool_executor_event(ctx.session_id, exec_event):
+    async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event, None]:
+        """Run tools for the turn and translate executor events to UI events."""
+
+        ctx = self._context
+        session_ctx = ctx.session_ctx
+        with tool_context(session_ctx.file_tracker, session_ctx.todo_context):
+            executor = ToolExecutor(
+                registry=ctx.tool_registry,
+                append_history=session_ctx.append_history,
+            )
+            self._tool_executor = executor
+            try:
+                async for exec_event in executor.run_tools(tool_calls):
+                    for ui_event in build_events_from_tool_executor_event(session_ctx.session_id, exec_event):
                         yield ui_event
+            finally:
                 self._tool_executor = None
-
-        yield events.TurnEndEvent(session_id=ctx.session_id)