klaude-code 2.8.1__py3-none-any.whl → 2.9.1__py3-none-any.whl

klaude_code/core/executor.py

@@ -676,6 +676,39 @@ class ExecutorContext:
             )
         )
 
+    async def handle_change_compact_model(self, operation: op.ChangeCompactModelOperation) -> None:
+        """Handle a change compact model operation."""
+        agent = await self._agent_runtime.ensure_agent(operation.session_id)
+        config = load_config()
+
+        model_name = operation.model_name
+
+        if model_name is None:
+            # Clear explicit override and use main client for compaction
+            self.llm_clients.compact = None
+            agent.compact_llm_client = None
+            display_model = "(inherit from main agent)"
+        else:
+            # Create new client for compaction
+            llm_config = config.get_model_config(model_name)
+            new_client = create_llm_client(llm_config)
+            self.llm_clients.compact = new_client
+            agent.compact_llm_client = new_client
+            display_model = new_client.model_name
+
+        if operation.save_as_default:
+            config.compact_model = model_name
+            await config.save()
+
+        saved_note = " (saved in ~/.klaude/klaude-config.yaml)" if operation.save_as_default else ""
+        await self.emit_event(
+            events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=commands.CommandName.SUB_AGENT_MODEL,
+                content=f"Compact model: {display_model}{saved_note}",
+            )
+        )
+
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         await self._agent_runtime.clear_session(operation.session_id)
 
@@ -763,11 +796,6 @@ class ExecutorContext:
             return None
         return active.task
 
-    def has_active_task(self, submission_id: str) -> bool:
-        """Return True if a task is registered for the submission id."""
-
-        return self.task_manager.get(submission_id) is not None
-
 
 class Executor:
     """

klaude_code/core/manager/llm_clients.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 
 from klaude_code.llm.client import LLMClientABC
+from klaude_code.protocol import tools
 from klaude_code.protocol.tools import SubAgentType
 
 
@@ -26,7 +27,14 @@ class LLMClients:
 
         if sub_agent_type is None:
             return self.main
-        return self.sub_clients.get(sub_agent_type) or self.main
+        client = self.sub_clients.get(sub_agent_type)
+        if client is not None:
+            return client
+        if sub_agent_type != tools.TASK:
+            fallback = self.sub_clients.get(tools.TASK)
+            if fallback is not None:
+                return fallback
+        return self.main
 
     def get_compact_client(self) -> LLMClientABC:
         """Return compact client if configured, otherwise main client."""

klaude_code/core/prompts/prompt-claude-code.md

@@ -72,16 +72,16 @@ The user will primarily request you perform software engineering tasks. This inc
 - Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are automatically added by the system, and bear no direct relation to the specific tool results or user messages in which they appear.
 
 ## Tool usage policy
-- When doing file search, prefer to use the Explore tool in order to reduce context usage.
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
 - You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.
 - If the user specifies that they want you to run tools "in parallel", you MUST send a single message with multiple tool use content blocks. For example, if you need to launch multiple agents in parallel, send a single message with multiple Task tool calls.
 - Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools: Read for reading files instead of cat/head/tail, Edit for editing instead of sed/awk. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the Explore tool instead of running search commands directly.
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the Task tool with subagent_type=Explore instead of running search commands directly.
 <example>
 user: Where are errors from the client handled?
-assistant: [Uses the Explore tool to find the files that handle client errors instead of using Glob or Grep directly]
+assistant: [Uses the Task tool with subagent_type=Explore to find the files that handle client errors instead of using Glob or Grep directly]
 </example>
 <example>
 user: What is the codebase structure?
-assistant: [Uses the Explore tool]
+assistant: [Uses the Task tool with subagent_type=Explore]
 </example>

klaude_code/core/reminders.py

@@ -21,20 +21,6 @@ AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P
 SKILL_PATTERN = re.compile(r"(?:^|\s)[$¥](?P<skill>\S+)")
 
 
-def get_last_new_user_input(session: Session) -> str | None:
-    """Get last user input & developer message (CLAUDE.md) from conversation history. if there's a tool result after user input, return None"""
-    result: list[str] = []
-    for item in reversed(session.conversation_history):
-        if isinstance(item, message.ToolResultMessage):
-            return None
-        if isinstance(item, message.UserMessage):
-            result.append(message.join_text_parts(item.parts))
-            break
-        if isinstance(item, message.DeveloperMessage):
-            result.append(message.join_text_parts(item.parts))
-    return "\n\n".join(result)
-
-
 @dataclass
 class AtPatternSource:
     """Represents an @ pattern with its source file (if from a memory file)."""
@@ -115,6 +101,7 @@ async def _load_at_file_recursive(
     at_ops: list[model.AtFileOp],
     formatted_blocks: list[str],
     collected_images: list[message.ImageURLPart],
+    collected_image_paths: list[str],
     visited: set[str],
     base_dir: Path | None = None,
     mentioned_in: str | None = None,
@@ -150,6 +137,7 @@ Result of calling the {tools.READ} tool:
         at_ops.append(model.AtFileOp(operation="Read", path=path_str, mentioned_in=mentioned_in))
         if images:
             collected_images.extend(images)
+            collected_image_paths.append(path_str)
 
         # Recursively parse @ references from ReadTool output
         output = tool_result.output_text
@@ -163,6 +151,7 @@ Result of calling the {tools.READ} tool:
                         at_ops,
                         formatted_blocks,
                         collected_images,
+                        collected_image_paths,
                         visited,
                         base_dir=path.parent,
                         mentioned_in=path_str,
@@ -193,6 +182,7 @@ async def at_file_reader_reminder(
     at_ops: list[model.AtFileOp] = []
     formatted_blocks: list[str] = []
     collected_images: list[message.ImageURLPart] = []
+    collected_image_paths: list[str] = []
     visited: set[str] = set()
 
     for source in at_pattern_sources:
@@ -202,6 +192,7 @@ async def at_file_reader_reminder(
             at_ops,
             formatted_blocks,
             collected_images,
+            collected_image_paths,
             visited,
             mentioned_in=source.mentioned_in,
         )
@@ -210,12 +201,15 @@ async def at_file_reader_reminder(
         return None
 
     at_files_str = "\n\n".join(formatted_blocks)
+    ui_items: list[model.DeveloperUIItem] = [model.AtFileOpsUIItem(ops=at_ops)]
+    if collected_image_paths:
+        ui_items.append(model.AtFileImagesUIItem(paths=collected_image_paths))
     return message.DeveloperMessage(
         parts=message.parts_from_text_and_images(
             f"""<system-reminder>{at_files_str}\n</system-reminder>""",
             collected_images or None,
         ),
-        ui_extra=model.DeveloperUIExtra(items=[model.AtFileOpsUIItem(ops=at_ops)]),
+        ui_extra=model.DeveloperUIExtra(items=ui_items),
     )
 
 
@@ -410,25 +404,29 @@ class Memory(BaseModel):
     content: str
 
 
-def get_last_user_message_image_count(session: Session) -> int:
-    """Get image count from the last user message in conversation history."""
+def get_last_user_message_image_paths(session: Session) -> list[str]:
+    """Get image file paths from the last user message in conversation history."""
     for item in reversed(session.conversation_history):
         if isinstance(item, message.ToolResultMessage):
-            return 0
+            return []
         if isinstance(item, message.UserMessage):
-            return len([part for part in item.parts if isinstance(part, message.ImageURLPart)])
-    return 0
+            paths: list[str] = []
+            for part in item.parts:
+                if isinstance(part, message.ImageFilePart):
+                    paths.append(part.file_path)
+            return paths
+    return []
 
 
 async def image_reminder(session: Session) -> message.DeveloperMessage | None:
     """Remind agent about images attached by user in the last message."""
-    image_count = get_last_user_message_image_count(session)
-    if image_count == 0:
+    image_paths = get_last_user_message_image_paths(session)
+    if not image_paths:
         return None
 
     return message.DeveloperMessage(
         parts=[],
-        ui_extra=model.DeveloperUIExtra(items=[model.UserImagesUIItem(count=image_count)]),
+        ui_extra=model.DeveloperUIExtra(items=[model.UserImagesUIItem(count=len(image_paths), paths=image_paths)]),
     )
 
 

klaude_code/core/task.py

@@ -179,10 +179,6 @@ class TaskExecutor:
         self._started_at: float = 0.0
         self._metadata_accumulator: MetadataAccumulator | None = None
 
-    @property
-    def current_turn(self) -> TurnExecutor | None:
-        return self._current_turn
-
     def get_partial_metadata(self) -> model.TaskMetadata | None:
         """Get the currently accumulated metadata without finalizing.
 
@@ -214,7 +210,7 @@ class TaskExecutor:
             accumulated = self._metadata_accumulator.get_partial_item(task_duration_s)
             if accumulated is not None:
                 session_id = self._context.session_ctx.session_id
-                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id, cancelled=True))
+                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id))
                 self._context.session_ctx.append_history([accumulated])
 
         return ui_events

klaude_code/core/tool/__init__.py

@@ -7,7 +7,7 @@ from .file.write_tool import WriteTool
 from .report_back_tool import ReportBackTool
 from .shell.bash_tool import BashTool
 from .shell.command_safety import SafetyCheckResult, is_safe_command
-from .sub_agent_tool import SubAgentTool
+from .sub_agent import ImageGenTool, TaskTool
 from .todo.todo_write_tool import TodoWriteTool
 from .todo.update_plan_tool import UpdatePlanTool
 from .tool_abc import ToolABC
@@ -23,13 +23,14 @@ __all__ = [
     "DiffError",
     "EditTool",
     "FileTracker",
+    "ImageGenTool",
     "MermaidTool",
     "ReadTool",
     "ReportBackTool",
     "RunSubtask",
     "SafetyCheckResult",
     "SubAgentResumeClaims",
-    "SubAgentTool",
+    "TaskTool",
     "TodoContext",
     "TodoWriteTool",
     "ToolABC",

klaude_code/core/tool/file/apply_patch.py

@@ -26,33 +26,6 @@ class Commit(BaseModel):
     changes: dict[str, FileChange] = Field(default_factory=dict)
 
 
-def assemble_changes(orig: dict[str, str | None], dest: dict[str, str | None]) -> Commit:
-    commit = Commit()
-    for path in sorted(set(orig.keys()).union(dest.keys())):
-        old_content = orig.get(path)
-        new_content = dest.get(path)
-        if old_content != new_content:
-            if old_content is not None and new_content is not None:
-                commit.changes[path] = FileChange(
-                    type=ActionType.UPDATE,
-                    old_content=old_content,
-                    new_content=new_content,
-                )
-            elif new_content:
-                commit.changes[path] = FileChange(
-                    type=ActionType.ADD,
-                    new_content=new_content,
-                )
-            elif old_content:
-                commit.changes[path] = FileChange(
-                    type=ActionType.DELETE,
-                    old_content=old_content,
-                )
-            else:
-                raise AssertionError()
-    return commit
-
-
 def _new_str_list() -> list[str]:
     # Returns a new list[str] for pydantic Field default_factory
     return []

klaude_code/core/tool/file/read_tool.md

@@ -4,10 +4,11 @@ When you need to read an image, use this tool.
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
+- By default, it reads up to ${line_cap} lines starting from the beginning of the file
 - This tool allows you to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as you are a multimodal LLM.
 - You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 2000 characters will be truncated
+- Any lines longer than ${char_limit_per_line} characters will be truncated
+- Total output is capped at ${max_chars} characters
 - Results are returned using cat -n format, with line numbers starting at 1
 - This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. 

klaude_code/core/tool/file/read_tool.py

@@ -22,6 +22,7 @@ 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_registry import register
 from klaude_code.protocol import llm_param, message, model, tools
+from klaude_code.protocol.model import ImageUIExtra, ReadPreviewLine, ReadPreviewUIExtra
 
 _IMAGE_MIME_TYPES: dict[str, str] = {
     ".png": "image/png",
@@ -164,7 +165,14 @@ class ReadTool(ToolABC):
         return llm_param.ToolSchema(
             name=tools.READ,
             type="function",
-            description=load_desc(Path(__file__).parent / "read_tool.md"),
+            description=load_desc(
+                Path(__file__).parent / "read_tool.md",
+                {
+                    "line_cap": str(READ_GLOBAL_LINE_CAP),
+                    "char_limit_per_line": str(READ_CHAR_LIMIT_PER_LINE),
+                    "max_chars": str(READ_MAX_CHARS),
+                },
+            ),
             parameters={
                 "type": "object",
                 "properties": {
@@ -280,7 +288,12 @@ class ReadTool(ToolABC):
             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 = message.ImageURLPart(url=data_url, id=None)
-            return message.ToolResultMessage(status="success", output_text=output_text, parts=[image_part])
+            return message.ToolResultMessage(
+                status="success",
+                output_text=output_text,
+                parts=[image_part],
+                ui_extra=ImageUIExtra(file_path=file_path),
+            )
 
         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)
@@ -333,4 +346,15 @@ class ReadTool(ToolABC):
         read_result_str = "\n".join(lines_out)
         _track_file_access(context.file_tracker, file_path, content_sha256=read_result.content_sha256)
 
-        return message.ToolResultMessage(status="success", output_text=read_result_str)
+        # When offset > 1, show a preview of the first 5 lines in UI
+        ui_extra = None
+        if args.offset is not None and args.offset > 1:
+            preview_count = 5
+            preview_lines = [
+                ReadPreviewLine(line_no=line_no, content=content)
+                for line_no, content in read_result.selected_lines[:preview_count]
+            ]
+            remaining = len(read_result.selected_lines) - len(preview_lines)
+            ui_extra = ReadPreviewUIExtra(lines=preview_lines, remaining_lines=remaining)
+
+        return message.ToolResultMessage(status="success", output_text=read_result_str, ui_extra=ui_extra)

klaude_code/core/tool/offload.py

@@ -68,13 +68,6 @@ class OffloadPolicy(Enum):
     ON_THRESHOLD = auto()  # Offload only when exceeding size threshold
 
 
-class TruncationStyle(Enum):
-    """How to truncate content that exceeds limits."""
-
-    HEAD_ONLY = auto()  # Keep head, discard tail (important content at top)
-    HEAD_TAIL = auto()  # Keep head and tail, discard middle (errors at end)
-
-
 @dataclass
 class OffloadResult:
     """Result of offload/truncation operation."""
@@ -94,18 +87,6 @@ class OffloadResult:
 class OffloadStrategy(ABC):
     """Base class for tool-specific offload strategies."""
 
-    @property
-    @abstractmethod
-    def offload_policy(self) -> OffloadPolicy:
-        """When to offload content to file."""
-        ...
-
-    @property
-    @abstractmethod
-    def truncation_style(self) -> TruncationStyle:
-        """How to truncate content."""
-        ...
-
     @abstractmethod
     def process(self, output: str, tool_call: ToolCallLike | None = None) -> OffloadResult:
         """Process tool output: truncate and optionally offload."""
@@ -126,14 +107,6 @@ class ReadToolStrategy(OffloadStrategy):
     This strategy is a pass-through since Read tool handles its own truncation.
     """
 
-    @property
-    def offload_policy(self) -> OffloadPolicy:
-        return OffloadPolicy.NEVER
-
-    @property
-    def truncation_style(self) -> TruncationStyle:
-        return TruncationStyle.HEAD_ONLY
-
     def process(self, output: str, tool_call: ToolCallLike | None = None) -> OffloadResult:
         return OffloadResult(output=output, was_truncated=False, original_length=len(output))
 
@@ -165,14 +138,6 @@ class HeadTailOffloadStrategy(OffloadStrategy):
         self.offload_dir = Path(offload_dir or TOOL_OUTPUT_TRUNCATION_DIR)
         self._policy = policy
 
-    @property
-    def offload_policy(self) -> OffloadPolicy:
-        return self._policy
-
-    @property
-    def truncation_style(self) -> TruncationStyle:
-        return TruncationStyle.HEAD_TAIL
-
     def _save_to_file(self, output: str, tool_call: ToolCallLike | None) -> str | None:
         """Save full output to file. Returns path or None on failure."""
         try:

klaude_code/core/tool/shell/bash_tool.py

@@ -342,7 +342,7 @@ class BashTool(ToolABC):
                 if not combined:
                     combined = f"Command exited with code {rc}"
                 return message.ToolResultMessage(
-                    status="error",
+                    status="success",
                     # Preserve leading whitespace; only trim trailing newlines.
                     output_text=combined.rstrip("\n"),
                 )

klaude_code/core/tool/sub_agent/__init__.py

@@ -0,0 +1,6 @@
+"""Sub-agent tool implementations."""
+
+from .image_gen import ImageGenTool
+from .task import TaskTool
+
+__all__ = ["ImageGenTool", "TaskTool"]

klaude_code/core/tool/sub_agent/image_gen.md

@@ -0,0 +1,16 @@
+Generate one or more images from a text prompt.
+
+This tool invokes an Image Gen model to generate images. The generated image paths are automatically returned in the response.
+
+Inputs:
+- `prompt`: The main instruction describing the desired image.
+- `image_paths` (optional): Local image file paths to use as references for editing or style guidance.
+- `generation` (optional): Per-call image generation settings (aspect ratio / size).
+
+Notes:
+- Provide a short textual description of the generated image(s).
+- Do NOT include base64 image data in text output.
+- When providing multiple input images, describe each image's characteristics and purpose in the prompt, not just "image 1, image 2".
+
+Multi-turn image editing:
+- Use `resume` to continue editing a previously generated image. The agent preserves its full context including the generated image, so you don't need to pass `image_paths` again.

klaude_code/core/tool/sub_agent/image_gen.py

@@ -0,0 +1,146 @@
+"""Image generation tool implementation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+from klaude_code.core.tool.context import ToolContext
+from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata, load_desc
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, message, model, tools
+from klaude_code.protocol.sub_agent import get_sub_agent_profile
+from klaude_code.protocol.sub_agent.image_gen import build_image_gen_prompt
+from klaude_code.session.session import Session
+
+IMAGE_GEN_PARAMETERS: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "resume": {
+            "type": "string",
+            "description": "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript.",
+        },
+        "description": {
+            "type": "string",
+            "description": "A short (3-5 word) description of the request.",
+        },
+        "prompt": {
+            "type": "string",
+            "description": "Text prompt for image generation.",
+        },
+        "image_paths": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Optional local image file paths used as references.",
+        },
+        "generation": {
+            "type": "object",
+            "description": "Optional per-call image generation settings.",
+            "properties": {
+                "aspect_ratio": {
+                    "type": "string",
+                    "description": "Aspect ratio, e.g. '16:9', '1:1', '9:16'.",
+                },
+                "image_size": {
+                    "type": "string",
+                    "enum": ["1K", "2K", "4K"],
+                    "description": "Output size for Nano Banana Pro (must use uppercase K).",
+                },
+            },
+            "additionalProperties": False,
+        },
+    },
+    "required": ["prompt"],
+    "additionalProperties": False,
+}
+
+
+@register(tools.IMAGE_GEN)
+class ImageGenTool(ToolABC):
+    """Generate or edit images using the ImageGen sub-agent."""
+
+    @classmethod
+    def metadata(cls) -> ToolMetadata:
+        return ToolMetadata(concurrency_policy=ToolConcurrencyPolicy.CONCURRENT, has_side_effects=True)
+
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.IMAGE_GEN,
+            type="function",
+            description=load_desc(Path(__file__).parent / "image_gen.md"),
+            parameters=IMAGE_GEN_PARAMETERS,
+        )
+
+    @classmethod
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
+        try:
+            args = json.loads(arguments)
+        except json.JSONDecodeError as exc:
+            return message.ToolResultMessage(status="error", output_text=f"Invalid JSON arguments: {exc}")
+
+        if not isinstance(args, dict):
+            return message.ToolResultMessage(status="error", output_text="Invalid arguments: expected object")
+
+        typed_args = cast(dict[str, Any], args)
+
+        runner = context.run_subtask
+        if runner is None:
+            return message.ToolResultMessage(status="error", output_text="No subtask runner available in this context")
+
+        resume_raw = typed_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 = context.sub_agent_resume_claims
+            if claims is not None:
+                ok = await claims.claim(resume_session_id)
+                if not ok:
+                    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."
+                        ),
+                    )
+
+        description = str(typed_args.get("description") or "")
+        prompt = build_image_gen_prompt(typed_args)
+        generation = typed_args.get("generation")
+        generation_dict: dict[str, Any] | None = (
+            cast(dict[str, Any], generation) if isinstance(generation, dict) else None
+        )
+
+        try:
+            profile = get_sub_agent_profile(tools.IMAGE_GEN)
+        except KeyError as exc:
+            return message.ToolResultMessage(status="error", output_text=str(exc))
+
+        try:
+            result = await runner(
+                model.SubAgentState(
+                    sub_agent_type=profile.name,
+                    sub_agent_desc=description,
+                    sub_agent_prompt=prompt,
+                    resume=resume_session_id,
+                    output_schema=None,
+                    generation=generation_dict,
+                ),
+                context.record_sub_agent_session_id,
+                context.register_sub_agent_metadata_getter,
+            )
+        except Exception as exc:
+            return message.ToolResultMessage(status="error", output_text=f"Failed to run subtask: {exc}")
+
+        return message.ToolResultMessage(
+            status="success" if not result.error else "error",
+            output_text=result.task_result,
+            ui_extra=model.SessionIdUIExtra(session_id=result.session_id),
+            task_metadata=result.task_metadata,
+        )

klaude_code/core/tool/sub_agent/task.md

@@ -0,0 +1,20 @@
+Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+Available agent types and the tools they have access to:
+
+${types_section}
+
+Usage notes:
+- Always include a short description (3-5 words) summarizing what the agent will do
+- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, etc.), since it is not aware of the user's intent
+- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.
+- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. When resumed, the agent continues with its full previous context preserved. When NOT resuming, each invocation starts fresh and you should provide a detailed task description with all necessary context.
+- When the agent is done, it will return a single message back to you along with its agent ID. You can use this ID to resume the agent later if needed for follow-up work.
+- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+- If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple Task tool use content blocks. For example, if you need to launch both a code-reviewer agent and a test-runner agent in parallel, send a single message with both tool calls.
+- Agents can provide structured output by passing a JSON Schema in `output_schema`.