klaude-code 1.9.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

klaude_code/core/tool/file/read_tool.py

@@ -10,12 +10,18 @@ from pathlib import Path
 
 from pydantic import BaseModel, Field
 
-from klaude_code import const
+from klaude_code.const import (
+    BINARY_CHECK_SIZE,
+    READ_CHAR_LIMIT_PER_LINE,
+    READ_GLOBAL_LINE_CAP,
+    READ_MAX_CHARS,
+    READ_MAX_IMAGE_BYTES,
+)
 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_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol import llm_param, model, tools
+from klaude_code.protocol import llm_param, message, model, tools
 
 _IMAGE_MIME_TYPES: dict[str, str] = {
     ".png": "image/png",
@@ -25,14 +31,12 @@ _IMAGE_MIME_TYPES: dict[str, str] = {
     ".webp": "image/webp",
 }
 
-_BINARY_CHECK_SIZE = 8192
-
 
 def _is_binary_file(file_path: str) -> bool:
     """Check if a file is binary by looking for null bytes in the first chunk."""
     try:
         with open(file_path, "rb") as f:
-            chunk = f.read(_BINARY_CHECK_SIZE)
+            chunk = f.read(BINARY_CHECK_SIZE)
             return b"\x00" in chunk
     except OSError:
         return False
@@ -48,9 +52,9 @@ class ReadOptions:
     file_path: str
     offset: int
     limit: int | None
-    char_limit_per_line: int | None = const.READ_CHAR_LIMIT_PER_LINE
-    global_line_cap: int | None = const.READ_GLOBAL_LINE_CAP
-    max_total_chars: int | None = const.READ_MAX_CHARS
+    char_limit_per_line: int | None = READ_CHAR_LIMIT_PER_LINE
+    global_line_cap: int | None = READ_GLOBAL_LINE_CAP
+    max_total_chars: int | None = READ_MAX_CHARS
 
 
 @dataclass
@@ -92,7 +96,7 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
                 truncated_chars = original_len - options.char_limit_per_line
                 content = (
                     content[: options.char_limit_per_line]
-                    + f" ... (more {truncated_chars} characters in this line are truncated)"
+                    + f" … (more {truncated_chars} characters in this line are truncated)"
                 )
             line_chars = len(content) + 1
             selected_chars += line_chars
@@ -178,42 +182,42 @@ class ReadTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = ReadTool.ReadArguments.model_validate_json(arguments)
         except Exception as e:  # pragma: no cover - defensive
-            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return message.ToolResultMessage(status="error", output_text=f"Invalid arguments: {e}")
         return await cls.call_with_args(args)
 
     @classmethod
     def _effective_limits(cls) -> tuple[int | None, int | None, int | None]:
         return (
-            const.READ_CHAR_LIMIT_PER_LINE,
-            const.READ_GLOBAL_LINE_CAP,
-            const.READ_MAX_CHARS,
+            READ_CHAR_LIMIT_PER_LINE,
+            READ_GLOBAL_LINE_CAP,
+            READ_MAX_CHARS,
         )
 
     @classmethod
-    async def call_with_args(cls, args: ReadTool.ReadArguments) -> model.ToolResultItem:
+    async def call_with_args(cls, args: ReadTool.ReadArguments) -> message.ToolResultMessage:
         file_path = os.path.abspath(args.file_path)
         char_per_line, line_cap, max_chars = cls._effective_limits()
 
         if is_directory(file_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
         if not file_exists(file_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>File does not exist.</tool_use_error>",
+                output_text="<tool_use_error>File does not exist.</tool_use_error>",
             )
 
         # Check for PDF files
         if Path(file_path).suffix.lower() == ".pdf":
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=(
+                output_text=(
                     "<tool_use_error>PDF files are not supported by this tool.\n"
                     "If there's an available skill for PDF, use it.\n"
                     "Or use a Python script with `pdfplumber` to extract text/tables:\n\n"
@@ -233,9 +237,9 @@ class ReadTool(ToolABC):
         is_image_file = _is_supported_image_file(file_path)
         # Check for binary files (skip for images which are handled separately)
         if not is_image_file and _is_binary_file(file_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=(
+                output_text=(
                     "<tool_use_error>This appears to be a binary file and cannot be read as text. "
                     "Use appropriate tools or libraries to handle binary files.</tool_use_error>"
                 ),
@@ -247,12 +251,13 @@ class ReadTool(ToolABC):
             size_bytes = 0
 
         if is_image_file:
-            if size_bytes > const.READ_MAX_IMAGE_BYTES:
+            if size_bytes > READ_MAX_IMAGE_BYTES:
                 size_mb = size_bytes / (1024 * 1024)
-                return model.ToolResultItem(
+                limit_mb = READ_MAX_IMAGE_BYTES / (1024 * 1024)
+                return message.ToolResultMessage(
                     status="error",
-                    output=(
-                        f"<tool_use_error>Image size ({size_mb:.2f}MB) exceeds maximum supported size (4.00MB) for inline transfer.</tool_use_error>"
+                    output_text=(
+                        f"<tool_use_error>Image size ({size_mb:.2f}MB) exceeds maximum supported size ({limit_mb:.2f}MB) for inline transfer.</tool_use_error>"
                     ),
                 )
             try:
@@ -261,16 +266,16 @@ class ReadTool(ToolABC):
                     image_bytes = image_file.read()
                 data_url = f"data:{mime_type};base64,{b64encode(image_bytes).decode('ascii')}"
             except Exception as exc:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output=f"<tool_use_error>Failed to read image file: {exc}</tool_use_error>",
+                    output_text=f"<tool_use_error>Failed to read image file: {exc}</tool_use_error>",
                 )
 
             _track_file_access(file_path, content_sha256=hashlib.sha256(image_bytes).hexdigest())
             size_kb = size_bytes / 1024.0 if size_bytes else 0.0
             output_text = f"[image] {Path(file_path).name} ({size_kb:.1f}KB)"
-            image_part = model.ImageURLPart(image_url=model.ImageURLPart.ImageURL(url=data_url, id=None))
-            return model.ToolResultItem(status="success", output=output_text, images=[image_part])
+            image_part = message.ImageURLPart(url=data_url, id=None)
+            return message.ToolResultMessage(status="success", output_text=output_text, parts=[image_part])
 
         offset = 1 if args.offset is None or args.offset < 1 else int(args.offset)
         limit = None if args.limit is None else int(args.limit)
@@ -291,36 +296,36 @@ class ReadTool(ToolABC):
             )
 
         except FileNotFoundError:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>File does not exist.</tool_use_error>",
+                output_text="<tool_use_error>File does not exist.</tool_use_error>",
             )
         except IsADirectoryError:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
 
         if offset > max(read_result.total_lines, 0):
             warn = f"<system-reminder>Warning: the file exists but is shorter than the provided offset ({offset}). The file has {read_result.total_lines} lines.</system-reminder>"
             _track_file_access(file_path, content_sha256=read_result.content_sha256)
-            return model.ToolResultItem(status="success", output=warn)
+            return message.ToolResultMessage(status="success", output_text=warn)
 
         lines_out: list[str] = [_format_numbered_line(no, content) for no, content in read_result.selected_lines]
 
         # Show truncation info with reason
         if read_result.remaining_due_to_char_limit > 0:
             lines_out.append(
-                f"... ({read_result.remaining_due_to_char_limit} more lines truncated due to {max_chars} char limit, "
+                f"… ({read_result.remaining_due_to_char_limit} more lines truncated due to {max_chars} char limit, "
                 f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
             )
         elif read_result.remaining_selected_beyond_cap > 0:
             lines_out.append(
-                f"... ({read_result.remaining_selected_beyond_cap} more lines truncated due to {line_cap} line limit, "
+                f"… ({read_result.remaining_selected_beyond_cap} more lines truncated due to {line_cap} line limit, "
                 f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
             )
 
         read_result_str = "\n".join(lines_out)
         _track_file_access(file_path, content_sha256=read_result.content_sha256)
 
-        return model.ToolResultItem(status="success", output=read_result_str)
+        return message.ToolResultMessage(status="success", output_text=read_result_str)

klaude_code/core/tool/file/write_tool.py

@@ -12,7 +12,7 @@ from klaude_code.core.tool.file.diff_builder import build_structured_diff
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol import llm_param, model, tools
+from klaude_code.protocol import llm_param, message, model, tools
 
 
 class WriteArguments(BaseModel):
@@ -46,18 +46,18 @@ class WriteTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = WriteArguments.model_validate_json(arguments)
         except ValueError as e:  # pragma: no cover - defensive
-            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return message.ToolResultMessage(status="error", output_text=f"Invalid arguments: {e}")
 
         file_path = os.path.abspath(args.file_path)
 
         if is_directory(file_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
             )
 
         file_tracker = get_current_file_tracker()
@@ -67,9 +67,9 @@ class WriteTool(ToolABC):
         if exists:
             tracked_status = file_tracker.get(file_path) if file_tracker is not None else None
             if tracked_status is None:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output=("File has not been read yet. Read it first before writing to it."),
+                    output_text=("File has not been read yet. Read it first before writing to it."),
                 )
 
         # Capture previous content (if any) for diff generation and external-change detection.
@@ -87,9 +87,9 @@ class WriteTool(ToolABC):
             if before_read_ok and tracked_status is not None and tracked_status.content_sha256 is not None:
                 current_sha256 = hash_text_sha256(before)
                 if current_sha256 != tracked_status.content_sha256:
-                    return model.ToolResultItem(
+                    return message.ToolResultMessage(
                         status="error",
-                        output=(
+                        output_text=(
                             "File has been modified externally. Either by user or a linter. "
                             "Read it first before writing to it."
                         ),
@@ -101,9 +101,9 @@ class WriteTool(ToolABC):
                 except OSError:
                     current_mtime = tracked_status.mtime
                 if current_mtime != tracked_status.mtime:
-                    return model.ToolResultItem(
+                    return message.ToolResultMessage(
                         status="error",
-                        output=(
+                        output_text=(
                             "File has been modified externally. Either by user or a linter. "
                             "Read it first before writing to it."
                         ),
@@ -112,7 +112,7 @@ class WriteTool(ToolABC):
         try:
             await asyncio.to_thread(write_text, file_path, args.content)
         except (OSError, UnicodeError) as e:  # pragma: no cover
-            return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
+            return message.ToolResultMessage(status="error", output_text=f"<tool_use_error>{e}</tool_use_error>")
 
         if file_tracker is not None:
             with contextlib.suppress(Exception):
@@ -132,5 +132,5 @@ class WriteTool(ToolABC):
         else:
             ui_extra = build_structured_diff(before, args.content, file_path=file_path)
 
-        message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
-        return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)
+        output_msg = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
+        return message.ToolResultMessage(status="success", output_text=output_msg, ui_extra=ui_extra)

klaude_code/core/tool/report_back_tool.py

@@ -2,7 +2,7 @@
 
 from typing import Any, ClassVar, cast
 
-from klaude_code.protocol import llm_param, model, tools
+from klaude_code.protocol import llm_param, message, tools
 
 
 def _normalize_schema_types(schema: dict[str, Any]) -> dict[str, Any]:
@@ -72,13 +72,13 @@ class ReportBackTool:
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         """Execute the report_back tool.
 
         The actual handling of report_back results is done by TurnExecutor.
         This method just returns a success status to maintain the tool call flow.
         """
-        return model.ToolResultItem(
+        return message.ToolResultMessage(
             status="success",
-            output="Result reported successfully. Task will end.",
+            output_text="Result reported successfully. Task will end.",
         )

klaude_code/core/tool/shell/bash_tool.py

@@ -10,12 +10,12 @@ from typing import Any
 
 from pydantic import BaseModel
 
-from klaude_code import const
+from klaude_code.const import BASH_DEFAULT_TIMEOUT_MS, BASH_TERMINATE_TIMEOUT_SEC
 from klaude_code.core.tool.shell.command_safety import is_safe_command
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol import llm_param, model, tools
+from klaude_code.protocol import llm_param, message, model, tools
 
 # Regex to strip ANSI and terminal control sequences from command output
 #
@@ -58,8 +58,8 @@ class BashTool(ToolABC):
                     },
                     "timeout_ms": {
                         "type": "integer",
-                        "description": f"The timeout for the command in milliseconds, default is {const.BASH_DEFAULT_TIMEOUT_MS}",
-                        "default": const.BASH_DEFAULT_TIMEOUT_MS,
+                        "description": f"The timeout for the command in milliseconds, default is {BASH_DEFAULT_TIMEOUT_MS}",
+                        "default": BASH_DEFAULT_TIMEOUT_MS,
                     },
                 },
                 "required": ["command"],
@@ -68,27 +68,27 @@ class BashTool(ToolABC):
 
     class BashArguments(BaseModel):
         command: str
-        timeout_ms: int = const.BASH_DEFAULT_TIMEOUT_MS
+        timeout_ms: int = BASH_DEFAULT_TIMEOUT_MS
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = BashTool.BashArguments.model_validate_json(arguments)
         except ValueError as e:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Invalid arguments: {e}",
+                output_text=f"Invalid arguments: {e}",
             )
         return await cls.call_with_args(args)
 
     @classmethod
-    async def call_with_args(cls, args: BashArguments) -> model.ToolResultItem:
+    async def call_with_args(cls, args: BashArguments) -> message.ToolResultMessage:
         # Safety check: only execute commands proven as "known safe"
         result = is_safe_command(args.command)
         if not result.is_safe:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Command rejected: {result.error_msg}",
+                output_text=f"Command rejected: {result.error_msg}",
             )
 
         # Run the command using bash -lc so shell semantics work (pipes, &&, etc.)
@@ -279,7 +279,7 @@ class BashTool(ToolABC):
                 pass
 
             with contextlib.suppress(Exception):
-                await asyncio.wait_for(proc.wait(), timeout=1.0)
+                await asyncio.wait_for(proc.wait(), timeout=BASH_TERMINATE_TIMEOUT_SEC)
                 return
 
             # Escalate to hard kill if it didn't exit quickly.
@@ -289,7 +289,7 @@ class BashTool(ToolABC):
                 else:
                     proc.kill()
             with contextlib.suppress(Exception):
-                await asyncio.wait_for(proc.wait(), timeout=1.0)
+                await asyncio.wait_for(proc.wait(), timeout=BASH_TERMINATE_TIMEOUT_SEC)
 
         try:
             # Create a dedicated process group so we can terminate the whole tree.
@@ -311,9 +311,9 @@ class BashTool(ToolABC):
             except TimeoutError:
                 with contextlib.suppress(Exception):
                     await _terminate_process(proc)
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output=f"Timeout after {args.timeout_ms} ms running: {args.command}",
+                    output_text=f"Timeout after {args.timeout_ms} ms running: {args.command}",
                 )
             except asyncio.CancelledError:
                 # Ensure subprocess is stopped and propagate cancellation.
@@ -332,11 +332,11 @@ class BashTool(ToolABC):
                     output = (output + ("\n" if output else "")) + f"[stderr]\n{stderr}"
 
                 _best_effort_update_file_tracker(args.command)
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="success",
                     # Preserve leading whitespace for tools like `nl -ba`.
                     # Only trim trailing newlines to avoid adding an extra blank line in the UI.
-                    output=output.rstrip("\n"),
+                    output_text=output.rstrip("\n"),
                 )
             else:
                 combined = ""
@@ -346,21 +346,21 @@ class BashTool(ToolABC):
                     combined += f"[stderr]\n{stderr}"
                 if not combined:
                     combined = f"Command exited with code {rc}"
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
                     # Preserve leading whitespace; only trim trailing newlines.
-                    output=combined.rstrip("\n"),
+                    output_text=combined.rstrip("\n"),
                 )
         except FileNotFoundError:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="bash not found on system path",
+                output_text="bash not found on system path",
             )
         except asyncio.CancelledError:
             # Propagate cooperative cancellation so outer layers can handle interrupts correctly.
             raise
         except OSError as e:  # safeguard: catch remaining OS-level errors (permissions, resources, etc.)
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Execution error: {e}",
+                output_text=f"Execution error: {e}",
             )

klaude_code/core/tool/skill/skill_tool.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel
 
 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, model, tools
+from klaude_code.protocol import llm_param, message, tools
 from klaude_code.skill import get_available_skills, get_skill, list_skill_names
 
 
@@ -55,23 +55,23 @@ class SkillTool(ToolABC):
         command: str
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         """Load and return full skill content."""
         try:
             args = cls.SkillArguments.model_validate_json(arguments)
         except ValueError as e:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Invalid arguments: {e}",
+                output_text=f"Invalid arguments: {e}",
             )
 
         skill = get_skill(args.command)
 
         if not skill:
             available = ", ".join(list_skill_names())
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Skill '{args.command}' does not exist. Available skills: {available}",
+                output_text=f"Skill '{args.command}' does not exist. Available skills: {available}",
             )
 
         # Get base directory from skill_path
@@ -84,4 +84,4 @@ class SkillTool(ToolABC):
 Base directory for this skill: {base_dir}
 
 {skill.to_prompt()}"""
-        return model.ToolResultItem(status="success", output=result)
+        return message.ToolResultMessage(status="success", output_text=result)

klaude_code/core/tool/sub_agent_tool.py

@@ -8,11 +8,12 @@ from __future__ import annotations
 
 import asyncio
 import json
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata
-from klaude_code.core.tool.tool_context import current_run_subtask_callback
-from klaude_code.protocol import llm_param, model
+from klaude_code.core.tool.tool_context import current_run_subtask_callback, current_sub_agent_resume_claims
+from klaude_code.protocol import llm_param, message, model
+from klaude_code.session.session import Session
 
 if TYPE_CHECKING:
     from klaude_code.protocol.sub_agent import SubAgentProfile
@@ -51,22 +52,48 @@ class SubAgentTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         profile = cls._profile
 
         try:
             args = json.loads(arguments)
         except json.JSONDecodeError as e:
-            return model.ToolResultItem(status="error", output=f"Invalid JSON arguments: {e}")
+            return message.ToolResultMessage(status="error", output_text=f"Invalid JSON arguments: {e}")
 
         runner = current_run_subtask_callback.get()
         if runner is None:
-            return model.ToolResultItem(status="error", output="No subtask runner available in this context")
+            return message.ToolResultMessage(status="error", output_text="No subtask runner available in this context")
 
         # Build the prompt using the profile's prompt builder
         prompt = profile.prompt_builder(args)
         description = args.get("description", "")
 
+        resume_raw = args.get("resume")
+        resume_session_id: str | None = None
+        if isinstance(resume_raw, str) and resume_raw.strip():
+            try:
+                resume_session_id = Session.resolve_sub_agent_session_id(resume_raw)
+            except ValueError as exc:
+                return message.ToolResultMessage(status="error", output_text=str(exc))
+
+            claims = current_sub_agent_resume_claims.get()
+            if claims is not None:
+                if resume_session_id in claims:
+                    return message.ToolResultMessage(
+                        status="error",
+                        output_text=(
+                            "Duplicate sub-agent resume in the same response: "
+                            f"resume='{resume_raw.strip()}' (resolved='{resume_session_id[:7]}…'). "
+                            "Merge into a single call or resume in a later turn."
+                        ),
+                    )
+                claims.add(resume_session_id)
+
+        generation = args.get("generation")
+        generation_dict: dict[str, Any] | None = (
+            cast(dict[str, Any], generation) if isinstance(generation, dict) else None
+        )
+
         # Extract output_schema if configured
         output_schema = None
         if profile.output_schema_arg:
@@ -78,17 +105,19 @@ class SubAgentTool(ToolABC):
                     sub_agent_type=profile.name,
                     sub_agent_desc=description,
                     sub_agent_prompt=prompt,
+                    resume=resume_session_id,
                     output_schema=output_schema,
+                    generation=generation_dict,
                 )
             )
         except asyncio.CancelledError:
             raise
         except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to run subtask: {e}")
+            return message.ToolResultMessage(status="error", output_text=f"Failed to run subtask: {e}")
 
-        return model.ToolResultItem(
+        return message.ToolResultMessage(
             status="success" if not result.error else "error",
-            output=result.task_result or "",
+            output_text=result.task_result,
             ui_extra=model.SessionIdUIExtra(session_id=result.session_id),
             task_metadata=result.task_metadata,
         )

klaude_code/core/tool/todo/todo_write_tool.py

@@ -5,7 +5,7 @@ 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
+from klaude_code.protocol import llm_param, message, model, tools
 
 
 def get_new_completed_todos(old_todos: list[model.TodoItem], new_todos: list[model.TodoItem]) -> list[str]:
@@ -77,21 +77,21 @@ class TodoWriteTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = TodoWriteArguments.model_validate_json(arguments)
         except ValueError as e:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"Invalid arguments: {e}",
+                output_text=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(
+            return message.ToolResultMessage(
                 status="error",
-                output="No active session found",
+                output_text="No active session found",
             )
 
         # Get current todos before updating (for comparison)
@@ -113,9 +113,9 @@ Your todo list has changed. DO NOT mention this explicitly to the user. Here are
 {model.todo_list_str(args.todos)}. Continue on with the tasks at hand if applicable.
 </system-reminder>"""
 
-        return model.ToolResultItem(
+        return message.ToolResultMessage(
             status="success",
-            output=response,
+            output_text=response,
             ui_extra=model.TodoListUIExtra(todo_list=ui_extra),
             side_effects=[model.ToolSideEffect.TODO_CHANGE],
         )