kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/tools/file/write.py

@@ -1,14 +1,17 @@
 from pathlib import Path
 from typing import Literal, override
 
-import aiofiles
-from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+from kaos.path import KaosPath
+from kosong.tooling import CallableTool2, ToolError, ToolReturnValue
 from pydantic import BaseModel, Field
 
+from kimi_cli.soul.agent import BuiltinSystemPromptArgs
 from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
+from kimi_cli.tools.display import DisplayBlock
 from kimi_cli.tools.file import FileActions
-from kimi_cli.tools.utils import ToolRejectedError
+from kimi_cli.tools.file.utils import build_diff_blocks
+from kimi_cli.tools.utils import ToolRejectedError, load_desc
+from kimi_cli.utils.path import is_within_directory
 
 
 class Params(BaseModel):
@@ -26,22 +29,21 @@ class Params(BaseModel):
 
 class WriteFile(CallableTool2[Params]):
     name: str = "WriteFile"
-    description: str = (Path(__file__).parent / "write.md").read_text(encoding="utf-8")
+    description: str = load_desc(Path(__file__).parent / "write.md")
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval):
+        super().__init__()
         self._work_dir = builtin_args.KIMI_WORK_DIR
         self._approval = approval
 
-    def _validate_path(self, path: Path) -> ToolError | None:
+    async def _validate_path(self, path: KaosPath) -> ToolError | None:
         """Validate that the path is safe to write."""
         # Check for path traversal attempts
-        resolved_path = path.resolve()
-        resolved_work_dir = self._work_dir.resolve()
+        resolved_path = path.canonical()
 
         # Ensure the path is within work directory
-        if not str(resolved_path).startswith(str(resolved_work_dir)):
+        if not is_within_directory(resolved_path, self._work_dir):
             return ToolError(
                 message=(
                     f"`{path}` is outside the working directory. "
@@ -52,12 +54,12 @@ class WriteFile(CallableTool2[Params]):
         return None
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
+    async def __call__(self, params: Params) -> ToolReturnValue:
         # TODO: checks:
         # - check if the path may contain secrets
         # - check if the file format is writable
         try:
-            p = Path(params.path)
+            p = KaosPath(params.path)
 
             if not p.is_absolute():
                 return ToolError(
@@ -69,11 +71,11 @@ class WriteFile(CallableTool2[Params]):
                 )
 
             # Validate path safety
-            path_error = self._validate_path(p)
+            path_error = await self._validate_path(p)
             if path_error:
                 return path_error
 
-            if not p.parent.exists():
+            if not await p.parent.exists():
                 return ToolError(
                     message=f"`{params.path}` parent directory does not exist.",
                     brief="Parent directory not found",
@@ -89,27 +91,46 @@ class WriteFile(CallableTool2[Params]):
                     brief="Invalid write mode",
                 )
 
+            file_existed = await p.exists()
+            old_text = None
+            if file_existed:
+                old_text = await p.read_text(errors="replace")
+
+            new_text = (
+                params.content if params.mode == "overwrite" else (old_text or "") + params.content
+            )
+            diff_blocks: list[DisplayBlock] = list(
+                build_diff_blocks(
+                    params.path,
+                    old_text or "",
+                    new_text,
+                )
+            )
+
             # Request approval
             if not await self._approval.request(
                 self.name,
                 FileActions.EDIT,
                 f"Write file `{params.path}`",
+                display=diff_blocks,
             ):
                 return ToolRejectedError()
 
-            # Determine file mode for aiofiles
-            file_mode = "w" if params.mode == "overwrite" else "a"
-
             # Write content to file
-            async with aiofiles.open(p, mode=file_mode, encoding="utf-8") as f:
-                await f.write(params.content)
+            match params.mode:
+                case "overwrite":
+                    await p.write_text(params.content)
+                case "append":
+                    await p.append_text(params.content)
 
             # Get file info for success message
-            file_size = p.stat().st_size
+            file_size = (await p.stat()).st_size
             action = "overwritten" if params.mode == "overwrite" else "appended to"
-            return ToolOk(
+            return ToolReturnValue(
+                is_error=False,
                 output="",
                 message=(f"File successfully {action}. Current size: {file_size} bytes."),
+                display=diff_blocks,
             )
 
         except Exception as e:

kimi_cli/tools/multiagent/__init__.py

@@ -0,0 +1,7 @@
+from .create import CreateSubagent
+from .task import Task
+
+__all__ = [
+    "Task",
+    "CreateSubagent",
+]

kimi_cli/tools/multiagent/create.md

@@ -0,0 +1,11 @@
+Create a custom subagent with specific system prompt and name for reuse.
+
+Usage:
+- Define specialized agents with custom roles and boundaries
+- Created agents can be referenced by name in the Task tool
+- Use this when you need a specific agent type not covered by predefined agents
+- The created agent configuration will be saved and can be used immediately
+
+Example workflow:
+1. Use CreateSubagent to define a specialized agent (e.g., 'code_reviewer')
+2. Use the Task tool with agent='code_reviewer' to launch the created agent

kimi_cli/tools/multiagent/create.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnValue
+from pydantic import BaseModel, Field
+
+from kimi_cli.soul.agent import Agent, Runtime
+from kimi_cli.soul.toolset import KimiToolset
+from kimi_cli.tools.utils import load_desc
+
+
+class Params(BaseModel):
+    name: str = Field(
+        description=(
+            "Unique name for this agent configuration (e.g., 'summarizer', 'code_reviewer'). "
+            "This name will be used to reference the agent in the Task tool."
+        )
+    )
+    system_prompt: str = Field(
+        description="System prompt defining the agent's role, capabilities, and boundaries."
+    )
+
+
+class CreateSubagent(CallableTool2[Params]):
+    name: str = "CreateSubagent"
+    description: str = load_desc(Path(__file__).parent / "create.md")
+    params: type[Params] = Params
+
+    def __init__(self, toolset: KimiToolset, runtime: Runtime):
+        super().__init__()
+        self._toolset = toolset
+        self._runtime = runtime
+
+    async def __call__(self, params: Params) -> ToolReturnValue:
+        if params.name in self._runtime.labor_market.subagents:
+            return ToolError(
+                message=f"Subagent with name '{params.name}' already exists.",
+                brief="Subagent already exists",
+            )
+
+        subagent = Agent(
+            name=params.name,
+            system_prompt=params.system_prompt,
+            toolset=self._toolset,  # share the same toolset as the parent agent
+            runtime=self._runtime.copy_for_dynamic_subagent(),
+        )
+        self._runtime.labor_market.add_dynamic_subagent(params.name, subagent)
+        return ToolOk(
+            output="Available subagents: " + ", ".join(self._runtime.labor_market.subagents.keys()),
+            message=f"Subagent '{params.name}' created successfully.",
+        )

kimi_cli/tools/{task/__init__.py → multiagent/task.py}

@@ -2,20 +2,23 @@ import asyncio
 from pathlib import Path
 from typing import override
 
-from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnValue
 from pydantic import BaseModel, Field
 
-from kimi_cli.agentspec import ResolvedAgentSpec, SubagentSpec
 from kimi_cli.soul import MaxStepsReached, get_wire_or_none, run_soul
-from kimi_cli.soul.agent import Agent, load_agent
+from kimi_cli.soul.agent import Agent, Runtime
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.soul.runtime import Runtime
+from kimi_cli.soul.toolset import get_current_tool_call_or_none
 from kimi_cli.tools.utils import load_desc
-from kimi_cli.utils.message import message_extract_text
 from kimi_cli.utils.path import next_available_rotation
-from kimi_cli.wire import WireUISide
-from kimi_cli.wire.message import ApprovalRequest, WireMessage
+from kimi_cli.wire import Wire
+from kimi_cli.wire.types import (
+    ApprovalRequest,
+    ApprovalRequestResolved,
+    SubagentEvent,
+    WireMessage,
+)
 
 # Maximum continuation attempts for task summary
 MAX_CONTINUE_ATTEMPTS = 1
@@ -49,61 +52,42 @@ class Task(CallableTool2[Params]):
     name: str = "Task"
     params: type[Params] = Params
 
-    def __init__(self, agent_spec: ResolvedAgentSpec, runtime: Runtime, **kwargs):
+    def __init__(self, runtime: Runtime):
         super().__init__(
             description=load_desc(
                 Path(__file__).parent / "task.md",
                 {
                     "SUBAGENTS_MD": "\n".join(
-                        f"- `{name}`: {spec.description}"
-                        for name, spec in agent_spec.subagents.items()
+                        f"- `{name}`: {desc}"
+                        for name, desc in runtime.labor_market.fixed_subagent_descs.items()
                     ),
                 },
             ),
-            **kwargs,
         )
-
-        self._runtime = runtime
+        self._labor_market = runtime.labor_market
         self._session = runtime.session
-        self._subagents: dict[str, Agent] = {}
 
-        try:
-            loop = asyncio.get_running_loop()
-            self._load_task = loop.create_task(self._load_subagents(agent_spec.subagents))
-        except RuntimeError:
-            # In case there's no running event loop, e.g., during synchronous tests
-            self._load_task = None
-            asyncio.run(self._load_subagents(agent_spec.subagents))
-
-    async def _load_subagents(self, subagent_specs: dict[str, SubagentSpec]) -> None:
-        """Load all subagents specified in the agent spec."""
-        for name, spec in subagent_specs.items():
-            agent = await load_agent(spec.path, self._runtime, mcp_configs=[])
-            self._subagents[name] = agent
-
-    async def _get_subagent_history_file(self) -> Path:
-        """Generate a unique history file path for subagent."""
-        main_history_file = self._session.history_file
-        subagent_base_name = f"{main_history_file.stem}_sub"
-        main_history_file.parent.mkdir(parents=True, exist_ok=True)  # just in case
-        sub_history_file = await next_available_rotation(
-            main_history_file.parent / f"{subagent_base_name}{main_history_file.suffix}"
+    async def _get_subagent_context_file(self) -> Path:
+        """Generate a unique context file path for subagent."""
+        main_context_file = self._session.context_file
+        subagent_base_name = f"{main_context_file.stem}_sub"
+        main_context_file.parent.mkdir(parents=True, exist_ok=True)  # just in case
+        sub_context_file = await next_available_rotation(
+            main_context_file.parent / f"{subagent_base_name}{main_context_file.suffix}"
         )
-        assert sub_history_file is not None
-        return sub_history_file
+        assert sub_context_file is not None
+        return sub_context_file
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
-        if self._load_task is not None:
-            await self._load_task
-            self._load_task = None
+    async def __call__(self, params: Params) -> ToolReturnValue:
+        subagents = self._labor_market.subagents
 
-        if params.subagent_name not in self._subagents:
+        if params.subagent_name not in subagents:
             return ToolError(
                 message=f"Subagent not found: {params.subagent_name}",
                 brief="Subagent not found",
             )
-        agent = self._subagents[params.subagent_name]
+        agent = subagents[params.subagent_name]
         try:
             result = await self._run_subagent(agent, params.prompt)
             return result
@@ -113,24 +97,35 @@ class Task(CallableTool2[Params]):
                 brief="Failed to run subagent",
             )
 
-    async def _run_subagent(self, agent: Agent, prompt: str) -> ToolReturnType:
+    async def _run_subagent(self, agent: Agent, prompt: str) -> ToolReturnValue:
         """Run subagent with optional continuation for task summary."""
         super_wire = get_wire_or_none()
         assert super_wire is not None
+        current_tool_call = get_current_tool_call_or_none()
+        assert current_tool_call is not None
+        current_tool_call_id = current_tool_call.id
 
         def _super_wire_send(msg: WireMessage) -> None:
-            if isinstance(msg, ApprovalRequest):
+            if isinstance(msg, ApprovalRequest | ApprovalRequestResolved):
+                # ApprovalRequest and ApprovalRequestResolved should be root level Wire messages
                 super_wire.soul_side.send(msg)
-            # TODO: visualize subagent behavior by sending other messages in some way
+                return
+
+            event = SubagentEvent(
+                task_tool_call_id=current_tool_call_id,
+                event=msg,
+            )
+            super_wire.soul_side.send(event)
 
-        async def _ui_loop_fn(wire: WireUISide) -> None:
+        async def _ui_loop_fn(wire: Wire) -> None:
+            wire_ui = wire.ui_side(merge=True)
             while True:
-                msg = await wire.receive()
+                msg = await wire_ui.receive()
                 _super_wire_send(msg)
 
-        subagent_history_file = await self._get_subagent_history_file()
-        context = Context(file_backend=subagent_history_file)
-        soul = KimiSoul(agent, runtime=self._runtime, context=context)
+        subagent_context_file = await self._get_subagent_context_file()
+        context = Context(file_backend=subagent_context_file)
+        soul = KimiSoul(agent, context=context)
 
         try:
             await run_soul(soul, prompt, _ui_loop_fn, asyncio.Event())
@@ -151,7 +146,7 @@ class Task(CallableTool2[Params]):
         if len(context.history) == 0 or context.history[-1].role != "assistant":
             return ToolError(message=_error_msg, brief="Failed to run subagent")
 
-        final_response = message_extract_text(context.history[-1])
+        final_response = context.history[-1].extract_text(sep="\n")
 
         # Check if response is too brief, if so, run again with continuation prompt
         n_attempts_remaining = MAX_CONTINUE_ATTEMPTS
@@ -160,6 +155,6 @@ class Task(CallableTool2[Params]):
 
             if len(context.history) == 0 or context.history[-1].role != "assistant":
                 return ToolError(message=_error_msg, brief="Failed to run subagent")
-            final_response = message_extract_text(context.history[-1])
+            final_response = context.history[-1].extract_text(sep="\n")
 
         return ToolOk(output=final_response)

kimi_cli/tools/shell/__init__.py

@@ -0,0 +1,120 @@
+import asyncio
+from collections.abc import Callable
+from pathlib import Path
+from typing import override
+
+import kaos
+from kaos import AsyncReadable
+from kosong.tooling import CallableTool2, ToolReturnValue
+from pydantic import BaseModel, Field
+
+from kimi_cli.soul.approval import Approval
+from kimi_cli.tools.utils import ToolRejectedError, ToolResultBuilder, load_desc
+from kimi_cli.utils.environment import Environment
+
+MAX_TIMEOUT = 5 * 60
+
+
+class Params(BaseModel):
+    command: str = Field(description="The bash command to execute.")
+    timeout: int = Field(
+        description=(
+            "The timeout in seconds for the command to execute. "
+            "If the command takes longer than this, it will be killed."
+        ),
+        default=60,
+        ge=1,
+        le=MAX_TIMEOUT,
+    )
+
+
+class Shell(CallableTool2[Params]):
+    name: str = "Shell"
+    params: type[Params] = Params
+
+    def __init__(self, approval: Approval, environment: Environment):
+        is_powershell = environment.shell_name == "Windows PowerShell"
+        super().__init__(
+            description=load_desc(
+                Path(__file__).parent / ("powershell.md" if is_powershell else "bash.md"),
+                {"SHELL": f"{environment.shell_name} (`{environment.shell_path}`)"},
+            )
+        )
+        self._approval = approval
+        self._is_powershell = is_powershell
+        self._shell_path = environment.shell_path
+
+    @override
+    async def __call__(self, params: Params) -> ToolReturnValue:
+        builder = ToolResultBuilder()
+
+        if not params.command:
+            return builder.error("Command cannot be empty.", brief="Empty command")
+
+        if not await self._approval.request(
+            self.name,
+            "run shell command",
+            f"Run command `{params.command}`",
+        ):
+            return ToolRejectedError()
+
+        def stdout_cb(line: bytes):
+            line_str = line.decode(encoding="utf-8", errors="replace")
+            builder.write(line_str)
+
+        def stderr_cb(line: bytes):
+            line_str = line.decode(encoding="utf-8", errors="replace")
+            builder.write(line_str)
+
+        try:
+            exitcode = await self._run_shell_command(
+                params.command, stdout_cb, stderr_cb, params.timeout
+            )
+
+            if exitcode == 0:
+                return builder.ok("Command executed successfully.")
+            else:
+                return builder.error(
+                    f"Command failed with exit code: {exitcode}.",
+                    brief=f"Failed with exit code: {exitcode}",
+                )
+        except TimeoutError:
+            return builder.error(
+                f"Command killed by timeout ({params.timeout}s)",
+                brief=f"Killed by timeout ({params.timeout}s)",
+            )
+
+    async def _run_shell_command(
+        self,
+        command: str,
+        stdout_cb: Callable[[bytes], None],
+        stderr_cb: Callable[[bytes], None],
+        timeout: int,
+    ) -> int:
+        async def _read_stream(stream: AsyncReadable, cb: Callable[[bytes], None]):
+            while True:
+                line = await stream.readline()
+                if line:
+                    cb(line)
+                else:
+                    break
+
+        process = await kaos.exec(*self._shell_args(command))
+
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(
+                    _read_stream(process.stdout, stdout_cb),
+                    _read_stream(process.stderr, stderr_cb),
+                ),
+                timeout,
+            )
+            return await process.wait()
+        except TimeoutError:
+            await process.kill()
+            raise
+
+    def _shell_args(self, command: str) -> tuple[str, ...]:
+        if self._is_powershell:
+            return (str(self._shell_path), "-command", command)
+        return (str(self._shell_path), "-c", command)

kimi_cli/tools/{bash → shell}/bash.md

@@ -1,4 +1,4 @@
-Execute a shell command. Use this tool to explore the filesystem, edit files, run scripts, get system information, etc.
+Execute a ${SHELL} command. Use this tool to explore the filesystem, edit files, run scripts, get system information, etc.
 
 **Output:**
 The stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command failed, the exit code will be provided in a system tag.
@@ -25,7 +25,6 @@ The stdout and stderr will be combined and returned as a string. The output may
 - File viewing/editing: cat, grep, head, tail, diff, patch
 - Text processing: awk, sed, sort, uniq, wc
 - System information/operations: ps, kill, top, df, free, uname, whoami, id, date
-- Package management: pip, uv, npm, yarn, bun, cargo
 - Network operations: curl, wget, ping, telnet, ssh
 - Archive operations: tar, zip, unzip
 - Other: Other commands available in the shell environment. Check the existence of a command by running `which <command>` before using it.

kimi_cli/tools/shell/powershell.md

@@ -0,0 +1,25 @@
+Execute a ${SHELL} command. Use this tool to explore the filesystem, inspect or edit files, run Windows scripts, collect system information, etc., whenever the agent is running on Windows.
+
+Note that you are running on Windows, so make sure to use Windows commands, paths, and conventions.
+
+**Output:**
+The stdout and stderr streams are combined and returned as a single string. Extremely long output may be truncated. When a command fails, the exit code is provided in a system tag.
+
+**Guidelines for safety and security:**
+- Every tool call starts a fresh ${SHELL} session. Environment variables, `cd` changes, and command history do not persist between calls.
+- Do not launch interactive programs or anything that is expected to block indefinitely; ensure each command finishes promptly. Provide a `timeout` argument for potentially long runs.
+- Avoid using `..` to leave the working directory, and never touch files outside that directory unless explicitly instructed.
+- Never attempt commands that require elevated (Administrator) privileges unless explicitly authorized.
+
+**Guidelines for efficiency:**
+- Chain related commands with `;` and use `if ($?)` or `if (-not $?)` to conditionally execute commands based on the success or failure of previous ones.
+- Redirect or pipe output with `>`, `>>`, `|`, and leverage `for /f`, `if`, and `set` to build richer one-liners instead of multiple tool calls.
+- Reuse built-in utilities (e.g., `findstr`, `where`) to filter, transform, or locate data in a single invocation.
+
+**Commands available:**
+- Shell environment: `cd`, `dir`, `set`, `setlocal`, `echo`, `call`, `where`
+- File operations: `type`, `copy`, `move`, `del`, `erase`, `mkdir`, `rmdir`, `attrib`, `mklink`
+- Text/search: `find`, `findstr`, `more`, `sort`, `Get-Content`
+- System info: `ver`, `systeminfo`, `tasklist`, `wmic`, `hostname`
+- Archives/scripts: `tar`, `Compress-Archive`, `powershell`, `python`, `node`
+- Other: Any other binaries available on the system PATH; run `where <command>` first if unsure.

kimi_cli/tools/test.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import override
 
-from kosong.tooling import CallableTool2, ToolOk, ToolReturnType
+from kosong.tooling import CallableTool2, ToolOk, ToolReturnValue
 from pydantic import BaseModel
 
 
@@ -16,7 +16,7 @@ class Plus(CallableTool2[PlusParams]):
     params: type[PlusParams] = PlusParams
 
     @override
-    async def __call__(self, params: PlusParams) -> ToolReturnType:
+    async def __call__(self, params: PlusParams) -> ToolReturnValue:
         return ToolOk(output=str(params.a + params.b))
 
 
@@ -31,7 +31,7 @@ class Compare(CallableTool2[CompareParams]):
     params: type[CompareParams] = CompareParams
 
     @override
-    async def __call__(self, params: CompareParams) -> ToolReturnType:
+    async def __call__(self, params: CompareParams) -> ToolReturnValue:
         if params.a > params.b:
             return ToolOk(output="greater")
         elif params.a < params.b:
@@ -50,6 +50,6 @@ class Panic(CallableTool2[PanicParams]):
     params: type[PanicParams] = PanicParams
 
     @override
-    async def __call__(self, params: PanicParams) -> ToolReturnType:
+    async def __call__(self, params: PanicParams) -> ToolReturnValue:
         await asyncio.sleep(2)
         raise Exception(f"panicked with a message with {len(params.message)} characters")

kimi_cli/tools/think/__init__.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 from typing import override
 
-from kosong.tooling import CallableTool2, ToolOk, ToolReturnType
+from kosong.tooling import CallableTool2, ToolOk, ToolReturnValue
 from pydantic import BaseModel, Field
 
 from kimi_cli.tools.utils import load_desc
@@ -17,5 +17,5 @@ class Think(CallableTool2[Params]):
     params: type[Params] = Params
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
+    async def __call__(self, params: Params) -> ToolReturnValue:
         return ToolOk(output="", message="Thought logged")

kimi_cli/tools/todo/__init__.py

@@ -1,13 +1,16 @@
 from pathlib import Path
 from typing import Literal, override
 
-from kosong.tooling import CallableTool2, ToolOk, ToolReturnType
+from kosong.tooling import CallableTool2, ToolReturnValue
 from pydantic import BaseModel, Field
 
+from kimi_cli.tools.display import TodoDisplayBlock, TodoDisplayItem
+from kimi_cli.tools.utils import load_desc
+
 
 class Todo(BaseModel):
     title: str = Field(description="The title of the todo", min_length=1)
-    status: Literal["Pending", "In Progress", "Done"] = Field(description="The status of the todo")
+    status: Literal["pending", "in_progress", "done"] = Field(description="The status of the todo")
 
 
 class Params(BaseModel):
@@ -16,12 +19,15 @@ class Params(BaseModel):
 
 class SetTodoList(CallableTool2[Params]):
     name: str = "SetTodoList"
-    description: str = (Path(__file__).parent / "set_todo_list.md").read_text(encoding="utf-8")
+    description: str = load_desc(Path(__file__).parent / "set_todo_list.md")
     params: type[Params] = Params
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
-        rendered = ""
-        for todo in params.todos:
-            rendered += f"- {todo.title} [{todo.status}]\n"
-        return ToolOk(output=rendered)
+    async def __call__(self, params: Params) -> ToolReturnValue:
+        items = [TodoDisplayItem(title=todo.title, status=todo.status) for todo in params.todos]
+        return ToolReturnValue(
+            is_error=False,
+            output="",
+            message="Todo list updated",
+            display=[TodoDisplayBlock(items=items)],
+        )