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

klaude_code/core/task.py

@@ -6,11 +6,11 @@ from collections.abc import AsyncGenerator, Callable, Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from klaude_code import const
+from klaude_code.const import INITIAL_RETRY_DELAY_S, MAX_FAILED_TURN_RETRIES, MAX_RETRY_DELAY_S
 from klaude_code.core.reminders import Reminder
 from klaude_code.core.tool import FileTracker, TodoContext, ToolABC
 from klaude_code.core.turn import TurnError, TurnExecutionContext, TurnExecutor
-from klaude_code.protocol import events, model
+from klaude_code.protocol import events, message, model
 from klaude_code.trace import DebugType, log_debug
 
 if TYPE_CHECKING:
@@ -33,38 +33,37 @@ class MetadataAccumulator:
         self._first_token_latency_count: int = 0
         self._turn_count: int = 0
 
-    def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
-        """Merge a turn's metadata into the accumulated state."""
+    def add(self, turn_usage: model.Usage) -> None:
+        """Merge a turn's usage into the accumulated state."""
         self._turn_count += 1
-        usage = turn_metadata.usage
+        usage = turn_usage
 
-        if usage is not None:
-            if self._main_agent.usage is None:
-                self._main_agent.usage = model.Usage()
-            acc_usage = self._main_agent.usage
+        if self._main_agent.usage is None:
+            self._main_agent.usage = model.Usage()
+        acc_usage = self._main_agent.usage
 
-            model.TaskMetadata.merge_usage(acc_usage, usage)
-            acc_usage.currency = usage.currency
+        model.TaskMetadata.merge_usage(acc_usage, usage)
+        acc_usage.currency = usage.currency
 
-            if usage.context_size is not None:
-                acc_usage.context_size = usage.context_size
-            if usage.context_limit is not None:
-                acc_usage.context_limit = usage.context_limit
+        if usage.context_size is not None:
+            acc_usage.context_size = usage.context_size
+        if usage.context_limit is not None:
+            acc_usage.context_limit = usage.context_limit
 
-            if usage.first_token_latency_ms is not None:
-                self._first_token_latency_sum += usage.first_token_latency_ms
-                self._first_token_latency_count += 1
+        if usage.first_token_latency_ms is not None:
+            self._first_token_latency_sum += usage.first_token_latency_ms
+            self._first_token_latency_count += 1
 
-            if usage.throughput_tps is not None:
-                current_output = usage.output_tokens
-                if current_output > 0:
-                    self._throughput_weighted_sum += usage.throughput_tps * current_output
-                    self._throughput_tracked_tokens += current_output
+        if usage.throughput_tps is not None:
+            current_output = usage.output_tokens
+            if current_output > 0:
+                self._throughput_weighted_sum += usage.throughput_tps * current_output
+                self._throughput_tracked_tokens += current_output
 
-        if turn_metadata.provider is not None:
-            self._main_agent.provider = turn_metadata.provider
-        if turn_metadata.model_name:
-            self._main_agent.model_name = turn_metadata.model_name
+        if usage.provider is not None:
+            self._main_agent.provider = usage.provider
+        if usage.model_name:
+            self._main_agent.model_name = usage.model_name
 
     def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
         """Add sub-agent task metadata to the accumulated state."""
@@ -98,8 +97,8 @@ class SessionContext:
     """
 
     session_id: str
-    get_conversation_history: Callable[[], list[model.ConversationItem]]
-    append_history: Callable[[Sequence[model.ConversationItem]], None]
+    get_conversation_history: Callable[[], list[message.HistoryEvent]]
+    append_history: Callable[[Sequence[message.HistoryEvent]], None]
     file_tracker: FileTracker
     todo_context: TodoContext
 
@@ -150,7 +149,7 @@ class TaskExecutor:
 
         return ui_events
 
-    async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event]:
+    async def run(self, user_input: message.UserInputPayload) -> AsyncGenerator[events.Event]:
         """Execute the task, yielding events as they occur."""
         ctx = self._context
         session_ctx = ctx.session_ctx
@@ -178,13 +177,14 @@ class TaskExecutor:
                 system_prompt=profile.system_prompt,
                 tools=profile.tools,
                 tool_registry=ctx.tool_registry,
+                sub_agent_state=ctx.sub_agent_state,
             )
 
             turn: TurnExecutor | None = None
             turn_succeeded = False
             last_error_message: str | None = None
 
-            for attempt in range(const.MAX_FAILED_TURN_RETRIES + 1):
+            for attempt in range(MAX_FAILED_TURN_RETRIES + 1):
                 turn = TurnExecutor(turn_context)
                 self._current_turn = turn
 
@@ -196,13 +196,12 @@ class TaskExecutor:
                             case events.ResponseMetadataEvent() as e:
                                 metadata_accumulator.add(e.metadata)
                                 # Emit context usage event if available
-                                if e.metadata.usage is not None:
-                                    context_percent = e.metadata.usage.context_usage_percent
-                                    if context_percent is not None:
-                                        yield events.ContextUsageEvent(
-                                            session_id=session_ctx.session_id,
-                                            context_percent=context_percent,
-                                        )
+                                context_percent = e.metadata.context_usage_percent
+                                if context_percent is not None:
+                                    yield events.ContextUsageEvent(
+                                        session_id=session_ctx.session_id,
+                                        context_percent=context_percent,
+                                    )
                             case events.ToolResultEvent() as e:
                                 # Collect sub-agent task metadata from tool results
                                 if e.task_metadata is not None:
@@ -215,9 +214,9 @@ class TaskExecutor:
                     break
                 except TurnError as e:
                     last_error_message = str(e)
-                    if attempt < const.MAX_FAILED_TURN_RETRIES:
+                    if attempt < MAX_FAILED_TURN_RETRIES:
                         delay = _retry_delay_seconds(attempt + 1)
-                        error_msg = f"Retrying {attempt + 1}/{const.MAX_FAILED_TURN_RETRIES} in {delay:.1f}s"
+                        error_msg = f"Retrying {attempt + 1}/{MAX_FAILED_TURN_RETRIES} in {delay:.1f}s"
                         if last_error_message:
                             error_msg = f"{error_msg} - {last_error_message}"
                         yield events.ErrorEvent(
@@ -233,7 +232,7 @@ class TaskExecutor:
                     style="red",
                     debug_type=DebugType.EXECUTION,
                 )
-                final_error = f"Turn failed after {const.MAX_FAILED_TURN_RETRIES} retries."
+                final_error = f"Turn failed after {MAX_FAILED_TURN_RETRIES} retries."
                 if last_error_message:
                     final_error = f"{last_error_message}\n{final_error}"
                 yield events.ErrorEvent(error_message=final_error, can_retry=False, session_id=session_ctx.session_id)
@@ -243,9 +242,9 @@ class TaskExecutor:
                 # Empty result should retry instead of finishing
                 if turn is not None and not turn.task_result.strip():
                     if ctx.sub_agent_state is not None:
-                        error_msg = "Sub-agent returned empty result, retrying..."
+                        error_msg = "Sub-agent returned empty result, retrying…"
                     else:
-                        error_msg = "Agent returned empty result, retrying..."
+                        error_msg = "Agent returned empty result, retrying…"
                     yield events.ErrorEvent(error_message=error_msg, can_retry=True, session_id=session_ctx.session_id)
                     continue
                 break
@@ -271,5 +270,5 @@ class TaskExecutor:
 def _retry_delay_seconds(attempt: int) -> float:
     """Compute exponential backoff delay for the given attempt count."""
     capped_attempt = max(1, attempt)
-    delay = const.INITIAL_RETRY_DELAY_S * (2 ** (capped_attempt - 1))
-    return min(delay, const.MAX_RETRY_DELAY_S)
+    delay = INITIAL_RETRY_DELAY_S * (2 ** (capped_attempt - 1))
+    return min(delay, MAX_RETRY_DELAY_S)

klaude_code/core/tool/file/apply_patch_tool.py

@@ -13,21 +13,21 @@ from klaude_code.core.tool.file.diff_builder import build_structured_file_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 ApplyPatchHandler:
     @classmethod
-    async def handle_apply_patch(cls, patch_text: str) -> model.ToolResultItem:
+    async def handle_apply_patch(cls, patch_text: str) -> message.ToolResultMessage:
         try:
             output, ui_extra = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
         except apply_patch_module.DiffError as error:
-            return model.ToolResultItem(status="error", output=str(error))
+            return message.ToolResultMessage(status="error", output_text=str(error))
         except Exception as error:  # pragma: no cover  # unexpected errors bubbled to tool result
-            return model.ToolResultItem(status="error", output=f"Execution error: {error}")
-        return model.ToolResultItem(
+            return message.ToolResultMessage(status="error", output_text=f"Execution error: {error}")
+        return message.ToolResultMessage(
             status="success",
-            output=output,
+            output_text=output,
             ui_extra=ui_extra,
         )
 
@@ -172,13 +172,13 @@ class ApplyPatchTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = cls.ApplyPatchArguments.model_validate_json(arguments)
         except ValueError as exc:
-            return model.ToolResultItem(status="error", output=f"Invalid arguments: {exc}")
+            return message.ToolResultMessage(status="error", output_text=f"Invalid arguments: {exc}")
         return await cls.call_with_args(args)
 
     @classmethod
-    async def call_with_args(cls, args: ApplyPatchArguments) -> model.ToolResultItem:
+    async def call_with_args(cls, args: ApplyPatchArguments) -> message.ToolResultMessage:
         return await ApplyPatchHandler.handle_apply_patch(args.patch)

klaude_code/core/tool/file/diff_builder.py

@@ -5,11 +5,9 @@ from typing import cast
 
 from diff_match_patch import diff_match_patch  # type: ignore[import-untyped]
 
+from klaude_code.const import DIFF_DEFAULT_CONTEXT_LINES, DIFF_MAX_LINE_LENGTH_FOR_CHAR_DIFF
 from klaude_code.protocol import model
 
-_MAX_LINE_LENGTH_FOR_CHAR_DIFF = 2000
-_DEFAULT_CONTEXT_LINES = 3
-
 
 def build_structured_diff(before: str, after: str, *, file_path: str) -> model.DiffUIExtra:
     """Build a structured diff with char-level spans for a single file."""
@@ -31,7 +29,7 @@ def _build_file_diff(before: str, after: str, *, file_path: str) -> model.DiffFi
     stats_add = 0
     stats_remove = 0
 
-    grouped_opcodes = matcher.get_grouped_opcodes(n=_DEFAULT_CONTEXT_LINES)
+    grouped_opcodes = matcher.get_grouped_opcodes(n=DIFF_DEFAULT_CONTEXT_LINES)
     for group_idx, group in enumerate(grouped_opcodes):
         if group_idx > 0:
             lines.append(_gap_line())
@@ -148,4 +146,4 @@ def _diff_line_spans(old_line: str, new_line: str) -> tuple[list[model.DiffSpan]
 
 
 def _should_char_diff(old_line: str, new_line: str) -> bool:
-    return len(old_line) <= _MAX_LINE_LENGTH_FOR_CHAR_DIFF and len(new_line) <= _MAX_LINE_LENGTH_FOR_CHAR_DIFF
+    return len(old_line) <= DIFF_MAX_LINE_LENGTH_FOR_CHAR_DIFF and len(new_line) <= DIFF_MAX_LINE_LENGTH_FOR_CHAR_DIFF

klaude_code/core/tool/file/edit_tool.py

@@ -13,7 +13,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
 
 
 @register(tools.EDIT)
@@ -85,25 +85,25 @@ class EditTool(ToolABC):
         return content.replace(old_string, new_string, 1)
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = EditTool.EditArguments.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)
 
         # Common file errors
         if is_directory(file_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
             )
 
         if args.old_string == "":
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=(
+                output_text=(
                     "<tool_use_error>old_string must not be empty for Edit. "
                     "To create or overwrite a file, use the Write tool instead.</tool_use_error>"
                 ),
@@ -114,25 +114,25 @@ class EditTool(ToolABC):
         tracked_status: model.FileStatus | None = None
         if not file_exists(file_path):
             # We require reading before editing
-            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."),
             )
         if file_tracker is not None:
             tracked_status = file_tracker.get(file_path)
             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."),
                 )
 
         # Edit existing file: validate and apply
         try:
             before = await asyncio.to_thread(read_text, file_path)
         except FileNotFoundError:
-            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.",
             )
 
         # Re-check external modifications using content hash when available.
@@ -140,9 +140,9 @@ class EditTool(ToolABC):
             if 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."
                         ),
                     )
@@ -153,9 +153,9 @@ class EditTool(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."
                         ),
                     )
@@ -167,7 +167,7 @@ class EditTool(ToolABC):
             replace_all=args.replace_all,
         )
         if err is not None:
-            return model.ToolResultItem(status="error", output=err)
+            return message.ToolResultMessage(status="error", output_text=err)
 
         after = cls.execute(
             content=before,
@@ -178,9 +178,9 @@ class EditTool(ToolABC):
 
         # If nothing changed due to replacement semantics (should not happen after valid), guard anyway
         if before == after:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=(
+                output_text=(
                     "<tool_use_error>No changes to make: old_string and new_string are exactly the same.</tool_use_error>"
                 ),
             )
@@ -189,7 +189,7 @@ class EditTool(ToolABC):
         try:
             await asyncio.to_thread(write_text, file_path, after)
         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>")
 
         # Prepare UI extra: unified diff with 3 context lines
         diff_lines = list(
@@ -217,7 +217,7 @@ class EditTool(ToolABC):
         # Build output message
         if args.replace_all:
             msg = f"The file {file_path} has been updated. All occurrences of '{args.old_string}' were successfully replaced with '{args.new_string}'."
-            return model.ToolResultItem(status="success", output=msg, ui_extra=ui_extra)
+            return message.ToolResultMessage(status="success", output_text=msg, ui_extra=ui_extra)
 
         # For single replacement, show a snippet consisting of context + added lines only
         # Parse the diff to collect target line numbers in the 'after' file
@@ -258,4 +258,4 @@ class EditTool(ToolABC):
             f"The file {file_path} has been updated. Here's the result of running `cat -n` on a snippet of the edited file:\n"
             f"{snippet}"
         )
-        return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
+        return message.ToolResultMessage(status="success", output_text=output, ui_extra=ui_extra)

klaude_code/core/tool/file/move_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 MoveArguments(BaseModel):
@@ -156,11 +156,11 @@ class MoveTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
+    async def call(cls, arguments: str) -> message.ToolResultMessage:
         try:
             args = MoveArguments.model_validate_json(arguments)
         except ValueError as e:
-            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return message.ToolResultMessage(status="error", output_text=f"Invalid arguments: {e}")
 
         source_path = os.path.abspath(args.source_file_path)
         target_path = os.path.abspath(args.target_file_path)
@@ -168,21 +168,21 @@ class MoveTool(ToolABC):
 
         # Validate paths
         if is_directory(source_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Source path is a directory, not a file.</tool_use_error>",
+                output_text="<tool_use_error>Source path is a directory, not a file.</tool_use_error>",
             )
         if is_directory(target_path):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Target path is a directory, not a file.</tool_use_error>",
+                output_text="<tool_use_error>Target path is a directory, not a file.</tool_use_error>",
             )
 
         # Validate line range
         if args.start_line > args.end_line:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>start_line must be <= end_line.</tool_use_error>",
+                output_text="<tool_use_error>start_line must be <= end_line.</tool_use_error>",
             )
 
         # Check file tracker
@@ -191,9 +191,9 @@ class MoveTool(ToolABC):
         target_exists = file_exists(target_path)
 
         if not source_exists:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Source file does not exist.</tool_use_error>",
+                output_text="<tool_use_error>Source file does not exist.</tool_use_error>",
             )
 
         source_status: model.FileStatus | None = None
@@ -202,47 +202,47 @@ class MoveTool(ToolABC):
         if file_tracker is not None:
             source_status = file_tracker.get(source_path)
             if source_status is None:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output="Source file has not been read yet. Read it first.",
+                    output_text="Source file has not been read yet. Read it first.",
                 )
             if target_exists:
                 target_status = file_tracker.get(target_path)
                 if target_status is None:
-                    return model.ToolResultItem(
+                    return message.ToolResultMessage(
                         status="error",
-                        output="Target file has not been read yet. Read it first before writing to it.",
+                        output_text="Target file has not been read yet. Read it first before writing to it.",
                     )
 
         # Read source file
         try:
             source_content = await asyncio.to_thread(read_text, source_path)
         except OSError as e:
-            return model.ToolResultItem(
-                status="error", output=f"<tool_use_error>Failed to read source: {e}</tool_use_error>"
+            return message.ToolResultMessage(
+                status="error", output_text=f"<tool_use_error>Failed to read source: {e}</tool_use_error>"
             )
 
         # Verify source hasn't been modified externally
         if source_status is not None and source_status.content_sha256 is not None:
             current_sha256 = hash_text_sha256(source_content)
             if current_sha256 != source_status.content_sha256:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output="Source file has been modified externally. Read it first before editing.",
+                    output_text="Source file has been modified externally. Read it first before editing.",
                 )
 
         source_lines = source_content.splitlines(keepends=True)
 
         # Validate line numbers against actual file
         if args.start_line > len(source_lines):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"<tool_use_error>start_line {args.start_line} exceeds file length {len(source_lines)}.</tool_use_error>",
+                output_text=f"<tool_use_error>start_line {args.start_line} exceeds file length {len(source_lines)}.</tool_use_error>",
             )
         if args.end_line > len(source_lines):
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output=f"<tool_use_error>end_line {args.end_line} exceeds file length {len(source_lines)}.</tool_use_error>",
+                output_text=f"<tool_use_error>end_line {args.end_line} exceeds file length {len(source_lines)}.</tool_use_error>",
             )
 
         # Extract the lines to move (convert to 0-indexed)
@@ -254,24 +254,24 @@ class MoveTool(ToolABC):
             try:
                 target_before = await asyncio.to_thread(read_text, target_path)
             except OSError as e:
-                return model.ToolResultItem(
-                    status="error", output=f"<tool_use_error>Failed to read target: {e}</tool_use_error>"
+                return message.ToolResultMessage(
+                    status="error", output_text=f"<tool_use_error>Failed to read target: {e}</tool_use_error>"
                 )
 
             # Verify target hasn't been modified externally
             if target_status is not None and target_status.content_sha256 is not None:
                 current_sha256 = hash_text_sha256(target_before)
                 if current_sha256 != target_status.content_sha256:
-                    return model.ToolResultItem(
+                    return message.ToolResultMessage(
                         status="error",
-                        output="Target file has been modified externally. Read it first before writing to it.",
+                        output_text="Target file has been modified externally. Read it first before writing to it.",
                     )
 
         # For new target file, only allow insert_line = 1
         if not target_exists and args.insert_line != 1:
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="error",
-                output="<tool_use_error>Target file does not exist. Use insert_line=1 to create new file.</tool_use_error>",
+                output_text="<tool_use_error>Target file does not exist. Use insert_line=1 to create new file.</tool_use_error>",
             )
 
         # Build new content for both files
@@ -288,16 +288,16 @@ class MoveTool(ToolABC):
                 adjusted_insert -= args.end_line - args.start_line + 1
             elif args.insert_line > args.start_line:
                 # Insert position is within the cut region - error
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output="<tool_use_error>insert_line cannot be within the cut range for same-file move.</tool_use_error>",
+                    output_text="<tool_use_error>insert_line cannot be within the cut range for same-file move.</tool_use_error>",
                 )
 
             # Validate adjusted insert line
             if adjusted_insert > len(new_lines) + 1:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output=f"<tool_use_error>insert_line {args.insert_line} is out of bounds after cut.</tool_use_error>",
+                    output_text=f"<tool_use_error>insert_line {args.insert_line} is out of bounds after cut.</tool_use_error>",
                 )
 
             # Insert at adjusted position
@@ -309,8 +309,8 @@ class MoveTool(ToolABC):
             try:
                 await asyncio.to_thread(write_text, source_path, source_after)
             except OSError as e:
-                return model.ToolResultItem(
-                    status="error", output=f"<tool_use_error>Failed to write: {e}</tool_use_error>"
+                return message.ToolResultMessage(
+                    status="error", output_text=f"<tool_use_error>Failed to write: {e}</tool_use_error>"
                 )
 
             # Update tracker
@@ -340,9 +340,9 @@ class MoveTool(ToolABC):
                 f"Source context (after cut):\n{cut_context}\n\n"
                 f"Insert context:\n{insert_context}"
             )
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="success",
-                output=output,
+                output_text=output,
                 ui_extra=ui_extra,
             )
         else:
@@ -356,9 +356,9 @@ class MoveTool(ToolABC):
 
             # Validate insert_line for existing target
             if target_exists and args.insert_line > len(target_lines) + 1:
-                return model.ToolResultItem(
+                return message.ToolResultMessage(
                     status="error",
-                    output=f"<tool_use_error>insert_line {args.insert_line} exceeds target file length + 1.</tool_use_error>",
+                    output_text=f"<tool_use_error>insert_line {args.insert_line} exceeds target file length + 1.</tool_use_error>",
                 )
 
             new_target_lines = target_lines[: args.insert_line - 1] + cut_lines + target_lines[args.insert_line - 1 :]
@@ -373,8 +373,8 @@ class MoveTool(ToolABC):
                 await asyncio.to_thread(write_text, source_path, source_after)
                 await asyncio.to_thread(write_text, target_path, target_after)
             except OSError as e:
-                return model.ToolResultItem(
-                    status="error", output=f"<tool_use_error>Failed to write: {e}</tool_use_error>"
+                return message.ToolResultMessage(
+                    status="error", output_text=f"<tool_use_error>Failed to write: {e}</tool_use_error>"
                 )
 
             # Update tracker for both files
@@ -428,8 +428,8 @@ class MoveTool(ToolABC):
                 f"Source file context (after move):\n{source_context}\n\n"
                 f"Target file context (after insert):\n{target_context}"
             )
-            return model.ToolResultItem(
+            return message.ToolResultMessage(
                 status="success",
-                output=output,
+                output_text=output,
                 ui_extra=ui_extra,
             )