klaude-code 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

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.
 

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/edit_tool.py

@@ -114,10 +114,9 @@ class EditTool(ToolABC):
         file_tracker = context.file_tracker
         tracked_status: model.FileStatus | None = None
         if not file_exists(file_path):
-            # We require reading before editing
             return message.ToolResultMessage(
                 status="error",
-                output_text=("File has not been read yet. Read it first before writing to it."),
+                output_text=("File does not exist. If you want to create a file, use the Write tool instead."),
             )
         tracked_status = file_tracker.get(file_path)
         if tracked_status is None:

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
 
 _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)

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/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`.