klaude-code 1.2.6__py3-none-any.whl

klaude_code/core/tool/todo/todo_write_tool.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_context import get_current_todo_context
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+
+def get_new_completed_todos(old_todos: list[model.TodoItem], new_todos: list[model.TodoItem]) -> list[str]:
+    """
+    Compare old and new todo lists to find newly completed todos.
+
+    Args:
+        old_todos: Previous todo list from session
+        new_todos: New todo list being set
+
+    Returns:
+        List of TodoItem content that were just completed (status changed to 'completed')
+    """
+    # Create a mapping of old todos by content for quick lookup
+    old_todos_map = {todo.content: todo for todo in old_todos}
+
+    new_completed: list[str] = []
+    for new_todo in new_todos:
+        # Check if this todo exists in the old list
+        old_todo = old_todos_map.get(new_todo.content)
+        if new_todo.status != "completed":
+            continue
+        if old_todo is not None:
+            # Todo existed before, check if status changed to completed
+            if old_todo.status != "completed":
+                new_completed.append(new_todo.content)
+        else:
+            # New completed todo
+            new_completed.append(new_todo.content)
+    return new_completed
+
+
+class TodoWriteArguments(BaseModel):
+    todos: list[model.TodoItem]
+
+
+@register(tools.TODO_WRITE)
+class TodoWriteTool(ToolABC):
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.TODO_WRITE,
+            type="function",
+            description=load_desc(Path(__file__).parent / "todo_write_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "todos": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "content": {"type": "string", "minLength": 1},
+                                "status": {
+                                    "type": "string",
+                                    "enum": ["pending", "in_progress", "completed"],
+                                },
+                                "activeForm": {"type": "string", "minLength": 1},
+                            },
+                            "required": ["content", "status", "activeForm"],
+                            "additionalProperties": False,
+                        },
+                        "description": "The updated todo list",
+                    }
+                },
+                "required": ["todos"],
+                "additionalProperties": False,
+            },
+        )
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = TodoWriteArguments.model_validate_json(arguments)
+        except ValueError as e:
+            return model.ToolResultItem(
+                status="error",
+                output=f"Invalid arguments: {e}",
+            )
+
+        # Get current todo context to store todos
+        todo_context = get_current_todo_context()
+        if todo_context is None:
+            return model.ToolResultItem(
+                status="error",
+                output="No active session found",
+            )
+
+        # Get current todos before updating (for comparison)
+        old_todos = todo_context.get_todos()
+
+        # Find newly completed todos
+        new_completed = get_new_completed_todos(old_todos, args.todos)
+
+        # Store todos via todo context
+        todo_context.set_todos(args.todos)
+
+        ui_extra = model.TodoUIExtra(todos=args.todos, new_completed=new_completed)
+
+        response = f"""Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable
+
+<system-reminder>
+Your todo list has changed. DO NOT mention this explicitly to the user. Here are the latest contents of your todo list:
+
+{model.todo_list_str(args.todos)}. Continue on with the tasks at hand if applicable.
+</system-reminder>"""
+
+        return model.ToolResultItem(
+            status="success",
+            output=response,
+            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            side_effects=[model.ToolSideEffect.TODO_CHANGE],
+        )

klaude_code/core/tool/todo/update_plan_tool.md

@@ -0,0 +1,3 @@
+Updates the task plan.
+Provide an optional explanation and a list of plan items, each with a step and status.
+At most one step can be in_progress at a time.

klaude_code/core/tool/todo/update_plan_tool.py

@@ -0,0 +1,104 @@
+"""
+update_plan tool: Codex variant of todo_write tool
+"""
+
+from pathlib import Path
+
+from pydantic import BaseModel, field_validator
+
+from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_context import get_current_todo_context
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+from .todo_write_tool import get_new_completed_todos
+
+
+class PlanItemArguments(BaseModel):
+    step: str
+    status: model.TodoStatusType
+
+    @field_validator("step")
+    @classmethod
+    def validate_step(cls, value: str) -> str:
+        if not value.strip():
+            raise ValueError("step must be a non-empty string")
+        return value
+
+
+class UpdatePlanArguments(BaseModel):
+    plan: list[PlanItemArguments]
+    explanation: str | None = None
+
+    @field_validator("plan")
+    @classmethod
+    def validate_plan(cls, value: list[PlanItemArguments]) -> list[PlanItemArguments]:
+        if not value:
+            raise ValueError("plan must contain at least one item")
+        in_progress_count = sum(1 for item in value if item.status == "in_progress")
+        if in_progress_count > 1:
+            raise ValueError("plan can have at most one in_progress step")
+        return value
+
+
+@register(tools.UPDATE_PLAN)
+class UpdatePlanTool(ToolABC):
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.UPDATE_PLAN,
+            type="function",
+            description=load_desc(Path(__file__).parent / "update_plan_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "explanation": {
+                        "type": "string",
+                        "description": "Optional explanation for the current plan state.",
+                    },
+                    "plan": {
+                        "type": "array",
+                        "description": "The list of steps",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "step": {"type": "string", "minLength": 1},
+                                "status": {
+                                    "type": "string",
+                                    "enum": ["pending", "in_progress", "completed"],
+                                },
+                            },
+                            "required": ["step", "status"],
+                            "additionalProperties": False,
+                        },
+                    },
+                },
+                "required": ["plan"],
+                "additionalProperties": False,
+            },
+        )
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = UpdatePlanArguments.model_validate_json(arguments)
+        except ValueError as exc:
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {exc}")
+
+        todo_context = get_current_todo_context()
+        if todo_context is None:
+            return model.ToolResultItem(status="error", output="No active session found")
+
+        new_todos = [model.TodoItem(content=item.step, status=item.status) for item in args.plan]
+        old_todos = todo_context.get_todos()
+        new_completed = get_new_completed_todos(old_todos, new_todos)
+        todo_context.set_todos(new_todos)
+
+        ui_extra = model.TodoUIExtra(todos=new_todos, new_completed=new_completed)
+
+        return model.ToolResultItem(
+            status="success",
+            output="Plan updated",
+            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            side_effects=[model.ToolSideEffect.TODO_CHANGE],
+        )

klaude_code/core/tool/tool_abc.py

@@ -0,0 +1,25 @@
+import string
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from klaude_code.protocol import llm_param, model
+
+
+def load_desc(path: Path, substitutions: dict[str, str] | None = None) -> str:
+    """Load a tool description from a file, with optional substitutions."""
+    description = path.read_text(encoding="utf-8")
+    if substitutions:
+        description = string.Template(description).substitute(substitutions)
+    return description
+
+
+class ToolABC(ABC):
+    @classmethod
+    @abstractmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        raise NotImplementedError

klaude_code/core/tool/tool_context.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Generator, MutableMapping
+from contextlib import contextmanager
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
+
+from klaude_code.protocol import model
+from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.session.session import Session
+
+
+@dataclass
+class TodoContext:
+    """Todo access interface exposed to tools.
+
+    Tools can only read the current todo list and replace it with
+    a new list; they cannot access the full Session object.
+    """
+
+    get_todos: Callable[[], list[model.TodoItem]]
+    set_todos: Callable[[list[model.TodoItem]], None]
+
+
+@dataclass
+class ToolContextToken:
+    """Tokens used to restore tool execution context.
+
+    This captures the contextvar tokens for the current file tracker
+    and todo context so callers can safely reset them after a tool
+    finishes running.
+    """
+
+    file_tracker_token: Token[MutableMapping[str, float] | None] | None
+    todo_token: Token[TodoContext | None] | None
+
+
+# Holds the current file tracker mapping for tool execution context.
+# Set by Agent/Reminder right before invoking a tool.
+current_file_tracker_var: ContextVar[MutableMapping[str, float] | None] = ContextVar(
+    "current_file_tracker", default=None
+)
+
+
+# Holds the todo access context for tools.
+current_todo_context_var: ContextVar[TodoContext | None] = ContextVar("current_todo_context", default=None)
+
+
+def set_tool_context_from_session(session: Session) -> ToolContextToken:
+    """Bind the given session's file tracker and todos into tool context.
+
+    This should be called by the Agent or reminder helpers immediately
+    before invoking tools so that file and todo tools can operate on
+    the correct per-session state without seeing the full Session.
+    """
+
+    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_token = current_todo_context_var.set(todo_ctx)
+    return ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
+
+
+def reset_tool_context(token: ToolContextToken) -> None:
+    """Restore tool execution context from a previously captured token."""
+
+    if token.file_tracker_token is not None:
+        current_file_tracker_var.reset(token.file_tracker_token)
+    if token.todo_token is not None:
+        current_todo_context_var.reset(token.todo_token)
+
+
+@contextmanager
+def tool_context(
+    file_tracker: MutableMapping[str, float], todo_ctx: TodoContext
+) -> Generator[ToolContextToken, None, None]:
+    """Context manager for setting and resetting tool execution context."""
+
+    file_tracker_token = current_file_tracker_var.set(file_tracker)
+    todo_token = current_todo_context_var.set(todo_ctx)
+    token = ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
+    try:
+        yield token
+    finally:
+        reset_tool_context(token)
+
+
+def get_current_file_tracker() -> MutableMapping[str, float] | None:
+    """Return the current file tracker mapping for this tool context."""
+
+    return current_file_tracker_var.get()
+
+
+def get_current_todo_context() -> TodoContext | None:
+    """Return the current todo access context for this tool context."""
+
+    return current_todo_context_var.get()
+
+
+# Holds a handle to run a nested subtask (sub-agent) from within a tool call.
+# The callable takes a model.SubAgentState and returns a SubAgentResult.
+current_run_subtask_callback: ContextVar[Callable[[model.SubAgentState], Awaitable[SubAgentResult]] | None] = (
+    ContextVar("current_run_subtask_callback", default=None)
+)

klaude_code/core/tool/tool_registry.py

@@ -0,0 +1,78 @@
+from typing import Callable, TypeVar
+
+from klaude_code.core.tool.sub_agent_tool import SubAgentTool
+from klaude_code.core.tool.tool_abc import ToolABC
+from klaude_code.protocol import llm_param, tools
+from klaude_code.protocol.sub_agent import get_sub_agent_profile, iter_sub_agent_profiles, sub_agent_tool_names
+
+_REGISTRY: dict[str, type[ToolABC]] = {}
+
+T = TypeVar("T", bound=ToolABC)
+
+
+def register(name: str) -> Callable[[type[T]], type[T]]:
+    def _decorator(cls: type[T]) -> type[T]:
+        _REGISTRY[name] = cls
+        return cls
+
+    return _decorator
+
+
+def _register_sub_agent_tools() -> None:
+    """Automatically register all sub-agent tools based on their profiles."""
+    for profile in iter_sub_agent_profiles():
+        tool_cls = SubAgentTool.for_profile(profile)
+        _REGISTRY[profile.name] = tool_cls
+
+
+_register_sub_agent_tools()
+
+
+def list_tools() -> list[str]:
+    return list(_REGISTRY.keys())
+
+
+def get_tool_schemas(tool_names: list[str]) -> list[llm_param.ToolSchema]:
+    schemas: list[llm_param.ToolSchema] = []
+    for tool_name in tool_names:
+        if tool_name not in _REGISTRY:
+            raise ValueError(f"Unknown Tool: {tool_name}")
+        schemas.append(_REGISTRY[tool_name].schema())
+    return schemas
+
+
+def get_registry() -> dict[str, type[ToolABC]]:
+    """Get the global tool registry."""
+    return _REGISTRY
+
+
+def load_agent_tools(
+    model_name: str, sub_agent_type: tools.SubAgentType | None = None, *, vanilla: bool = False
+) -> list[llm_param.ToolSchema]:
+    """Get tools for an agent based on model and agent type.
+
+    Args:
+        model_name: The model name.
+        sub_agent_type: If None, returns main agent tools. Otherwise returns sub-agent tools.
+        vanilla: If True, returns minimal vanilla tools (ignores sub_agent_type).
+    """
+    if vanilla:
+        return get_tool_schemas([tools.BASH, tools.EDIT, tools.WRITE, tools.READ])
+
+    if sub_agent_type is not None:
+        profile = get_sub_agent_profile(sub_agent_type)
+        if not profile.enabled_for_model(model_name):
+            return []
+        return get_tool_schemas(list(profile.tool_set))
+
+    # Main agent tools
+    if "gpt-5" in model_name:
+        tool_names = [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]
+
+    tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
+    tool_names.extend([tools.SKILL, tools.MERMAID, tools.MEMORY])
+    return get_tool_schemas(tool_names)

klaude_code/core/tool/tool_runner.py

@@ -0,0 +1,252 @@
+import asyncio
+from collections.abc import AsyncGenerator, Callable, Iterable, Sequence
+from dataclasses import dataclass
+
+from klaude_code import const
+from klaude_code.core.tool.tool_abc import ToolABC
+from klaude_code.core.tool.truncation import truncate_tool_output
+from klaude_code.protocol import model
+from klaude_code.protocol.sub_agent import is_sub_agent_tool
+
+
+async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolABC]]) -> model.ToolResultItem:
+    """Execute a tool call and return the result.
+
+    Args:
+        tool_call: The tool call to execute.
+        registry: The tool registry mapping tool names to tool classes.
+
+    Returns:
+        The result of the tool execution.
+    """
+    if tool_call.name not in registry:
+        return model.ToolResultItem(
+            call_id=tool_call.call_id,
+            output=f"Tool {tool_call.name} not exists",
+            status="error",
+            tool_name=tool_call.name,
+        )
+    try:
+        tool_result = await registry[tool_call.name].call(tool_call.arguments)
+        tool_result.call_id = tool_call.call_id
+        tool_result.tool_name = tool_call.name
+        if tool_result.output:
+            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,
+                    ),
+                )
+        return tool_result
+    except asyncio.CancelledError:
+        # Propagate cooperative cancellation so outer layers can handle interrupts correctly.
+        raise
+    except Exception as e:
+        return model.ToolResultItem(
+            call_id=tool_call.call_id,
+            output=f"Tool {tool_call.name} execution error: {e.__class__.__name__} {e}",
+            status="error",
+            tool_name=tool_call.name,
+        )
+
+
+@dataclass
+class ToolExecutionCallStarted:
+    """Represents the start of a tool call execution."""
+
+    tool_call: model.ToolCallItem
+
+
+@dataclass
+class ToolExecutionResult:
+    """Represents the completion of a tool call with its result."""
+
+    tool_call: model.ToolCallItem
+    tool_result: model.ToolResultItem
+
+
+@dataclass
+class ToolExecutionTodoChange:
+    """Represents a todo list change side effect emitted by a tool."""
+
+    todos: list[model.TodoItem]
+
+
+ToolExecutorEvent = ToolExecutionCallStarted | ToolExecutionResult | ToolExecutionTodoChange
+
+
+class ToolExecutor:
+    """Execute and coordinate a batch of tool calls for a single turn.
+
+    The executor is responsible for:
+    - Partitioning tool calls into regular tools and sub-agent tools
+    - Running regular tools sequentially and sub-agent tools concurrently
+    - Emitting ToolCall/ToolResult events and tool side-effect events
+    - Tracking unfinished calls so `cancel()` can synthesize cancellation results
+    """
+
+    def __init__(
+        self,
+        *,
+        registry: dict[str, type[ToolABC]],
+        append_history: Callable[[Sequence[model.ConversationItem]], None],
+    ) -> None:
+        self._registry = registry
+        self._append_history = append_history
+
+        self._unfinished_calls: dict[str, model.ToolCallItem] = {}
+        self._call_event_emitted: set[str] = set()
+        self._sub_agent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
+
+    async def run_tools(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[ToolExecutorEvent, None]:
+        """Run the given tool calls and yield execution events.
+
+        Tool calls are partitioned into regular tools and sub-agent tools. Regular tools
+        run sequentially, while sub-agent tools run concurrently. All results are
+        appended to history via the injected `append_history` callback.
+        """
+
+        for tool_call in tool_calls:
+            self._unfinished_calls[tool_call.call_id] = tool_call
+
+        regular_tool_calls, sub_agent_tool_calls = self._partition_tool_calls(tool_calls)
+
+        # Run regular tools sequentially.
+        for tool_call in regular_tool_calls:
+            tool_call_event = self._build_tool_call_started(tool_call)
+            self._call_event_emitted.add(tool_call.call_id)
+            yield tool_call_event
+
+            try:
+                result_events = await self._run_single_tool_call(tool_call)
+            except asyncio.CancelledError:
+                # Propagate cooperative cancellation so the agent task can be stopped.
+                raise
+
+            for exec_event in result_events:
+                yield exec_event
+
+        # Run sub-agent tools concurrently.
+        if sub_agent_tool_calls:
+            execution_tasks: list[asyncio.Task[list[ToolExecutorEvent]]] = []
+            for tool_call in sub_agent_tool_calls:
+                tool_call_event = self._build_tool_call_started(tool_call)
+                self._call_event_emitted.add(tool_call.call_id)
+                yield tool_call_event
+
+                task = asyncio.create_task(self._run_single_tool_call(tool_call))
+                self._register_sub_agent_task(task)
+                execution_tasks.append(task)
+
+            for task in asyncio.as_completed(execution_tasks):
+                # Do not swallow asyncio.CancelledError here:
+                # - If the user interrupts the main agent, the executor cancels the
+                #   outer agent task, which should propagate cancellation up through
+                #   tool execution so the task can terminate and emit TaskFinishEvent.
+                # - Sub-agent tool tasks cancelled via ToolExecutor.cancel() are
+                #   handled by synthesizing ToolExecutionResult events; any
+                #   CancelledError raised here should still bubble up so the
+                #   calling agent can stop cleanly, matching pre-refactor behavior.
+                result_events = await task
+
+                for exec_event in result_events:
+                    yield exec_event
+
+    def cancel(self) -> Iterable[ToolExecutorEvent]:
+        """Cancel unfinished tool calls and synthesize error results.
+
+        - Cancels any running sub-agent tool tasks so they stop emitting events.
+        - For each unfinished tool call, yields a ToolExecutionCallStarted (if not
+          already emitted for this turn) followed by a ToolExecutionResult with
+          error status and a standard cancellation output. The corresponding
+          ToolResultItem is appended to history via `append_history`.
+        """
+
+        events_to_yield: list[ToolExecutorEvent] = []
+
+        # Cancel running sub-agent tool tasks.
+        for task in list(self._sub_agent_tasks):
+            if not task.done():
+                task.cancel()
+        self._sub_agent_tasks.clear()
+
+        if not self._unfinished_calls:
+            return events_to_yield
+
+        for call_id, tool_call in list(self._unfinished_calls.items()):
+            cancel_result = model.ToolResultItem(
+                call_id=tool_call.call_id,
+                output=const.CANCEL_OUTPUT,
+                status="error",
+                tool_name=tool_call.name,
+                ui_extra=None,
+            )
+
+            if call_id not in self._call_event_emitted:
+                events_to_yield.append(ToolExecutionCallStarted(tool_call=tool_call))
+                self._call_event_emitted.add(call_id)
+
+            events_to_yield.append(ToolExecutionResult(tool_call=tool_call, tool_result=cancel_result))
+
+            self._append_history([cancel_result])
+            self._unfinished_calls.pop(call_id, None)
+
+        return events_to_yield
+
+    def _register_sub_agent_task(self, task: asyncio.Task[list[ToolExecutorEvent]]) -> None:
+        self._sub_agent_tasks.add(task)
+
+        def _cleanup(completed: asyncio.Task[list[ToolExecutorEvent]]) -> None:
+            self._sub_agent_tasks.discard(completed)
+
+        task.add_done_callback(_cleanup)
+
+    @staticmethod
+    def _partition_tool_calls(
+        tool_calls: list[model.ToolCallItem],
+    ) -> tuple[list[model.ToolCallItem], list[model.ToolCallItem]]:
+        regular_tool_calls: list[model.ToolCallItem] = []
+        sub_agent_tool_calls: list[model.ToolCallItem] = []
+        for tool_call in tool_calls:
+            if is_sub_agent_tool(tool_call.name):
+                sub_agent_tool_calls.append(tool_call)
+            else:
+                regular_tool_calls.append(tool_call)
+        return regular_tool_calls, sub_agent_tool_calls
+
+    def _build_tool_call_started(self, tool_call: model.ToolCallItem) -> ToolExecutionCallStarted:
+        return ToolExecutionCallStarted(tool_call=tool_call)
+
+    async def _run_single_tool_call(self, tool_call: model.ToolCallItem) -> list[ToolExecutorEvent]:
+        tool_result: model.ToolResultItem = await run_tool(tool_call, self._registry)
+
+        self._append_history([tool_result])
+
+        result_event = ToolExecutionResult(tool_call=tool_call, tool_result=tool_result)
+
+        self._unfinished_calls.pop(tool_call.call_id, None)
+
+        extra_events = self._build_tool_side_effect_events(tool_result)
+        return [result_event, *extra_events]
+
+    def _build_tool_side_effect_events(self, tool_result: model.ToolResultItem) -> list[ToolExecutorEvent]:
+        side_effects = tool_result.side_effects
+        if not side_effects:
+            return []
+
+        side_effect_events: list[ToolExecutorEvent] = []
+
+        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:
+                    todos = tool_result.ui_extra.todo_list.todos
+                if todos is not None:
+                    side_effect_events.append(ToolExecutionTodoChange(todos=todos))
+
+        return side_effect_events