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

klaude_code/protocol/op.py

@@ -14,7 +14,7 @@ from uuid import uuid4
 from pydantic import BaseModel, Field
 
 from klaude_code.protocol.llm_param import Thinking
-from klaude_code.protocol.model import UserInputPayload
+from klaude_code.protocol.message import UserInputPayload
 
 if TYPE_CHECKING:
     from klaude_code.protocol.op_handler import OperationHandler
@@ -23,7 +23,6 @@ if TYPE_CHECKING:
 class OperationType(Enum):
     """Enumeration of supported operation types."""
 
-    USER_INPUT = "user_input"
     RUN_AGENT = "run_agent"
     CHANGE_MODEL = "change_model"
     CHANGE_THINKING = "change_thinking"
@@ -46,18 +45,6 @@ class Operation(BaseModel):
         raise NotImplementedError("Subclasses must implement execute()")
 
 
-class UserInputOperation(Operation):
-    """Operation for handling user input (text and optional images) that should be processed by an agent."""
-
-    type: OperationType = OperationType.USER_INPUT
-    input: UserInputPayload
-    session_id: str | None = None
-
-    async def execute(self, handler: OperationHandler) -> None:
-        """Execute user input by running it through an agent."""
-        await handler.handle_user_input(self)
-
-
 class RunAgentOperation(Operation):
     """Operation for launching an agent task for a given session."""
 
@@ -84,7 +71,7 @@ class ChangeModelOperation(Operation):
     # This is useful for in-prompt model switching where extra output is noisy.
     emit_welcome_event: bool = True
 
-    # When False, do not emit the "Switched to: ..." developer message.
+    # When False, do not emit the "Switched to: …" developer message.
     # This is useful for in-prompt model switching where extra output is noisy.
     emit_switch_message: bool = True
 

klaude_code/protocol/op_handler.py

@@ -18,17 +18,12 @@ if TYPE_CHECKING:
         InterruptOperation,
         ResumeSessionOperation,
         RunAgentOperation,
-        UserInputOperation,
     )
 
 
 class OperationHandler(Protocol):
     """Protocol defining the interface for handling operations."""
 
-    async def handle_user_input(self, operation: UserInputOperation) -> None:
-        """Handle a user input operation."""
-        ...
-
     async def handle_run_agent(self, operation: RunAgentOperation) -> None:
         """Handle a run agent operation."""
         ...

klaude_code/protocol/sub_agent/__init__.py

@@ -112,5 +112,6 @@ def sub_agent_tool_names(enabled_only: bool = False, model_name: str | None = No
 
 # Import sub-agent modules to trigger registration
 from klaude_code.protocol.sub_agent import explore as explore  # noqa: E402
+from klaude_code.protocol.sub_agent import image_gen as image_gen  # noqa: E402
 from klaude_code.protocol.sub_agent import task as task  # noqa: E402
 from klaude_code.protocol.sub_agent import web as web  # noqa: E402

klaude_code/protocol/sub_agent/explore.py

@@ -14,11 +14,21 @@ Always spawn multiple search agents in parallel to maximise speed.
 Structured output:
 - Provide an `output_format` (JSON Schema) parameter for structured data back from the sub-agent
 - Example: `output_format={"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "List of file paths that match the search criteria, e.g. ['src/main.py', 'src/utils/helper.py']"}}, "required": ["files"]}`\
+
+- 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.
 """
 
 EXPLORE_PARAMETERS = {
     "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": "Short (3-5 words) label for the exploration goal",

klaude_code/protocol/sub_agent/image_gen.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from klaude_code.protocol.sub_agent import SubAgentProfile, register_sub_agent
+
+IMAGE_GEN_DESCRIPTION = """\
+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" - the image model cannot distinguish image order. \
+For example: "Edit the first image (a photo of a cat sitting on a windowsill) to match the style of \
+the second image (Van Gogh's Starry Night painting with swirling blue brushstrokes)."
+
+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.
+- Example workflow:
+  1. Call ImageGen with prompt="Generate a watercolor painting of a mountain lake" -> returns agent_id
+  2. Call ImageGen with resume=agent_id, prompt="Add a wooden cabin on the shore" -> edits the previous image
+  3. Call ImageGen with resume=agent_id, prompt="Change to sunset lighting" -> continues editing
+
+- 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.
+
+"""
+
+
+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).",
+                },
+                "extra": {
+                    "type": "object",
+                    "description": "Provider/model-specific extra parameters (future-proofing).",
+                },
+            },
+            "additionalProperties": False,
+        },
+    },
+    "required": ["prompt"],
+    "additionalProperties": False,
+}
+
+
+def _quote_at_pattern_path(path: str) -> str:
+    if any(ch.isspace() for ch in path) or '"' in path:
+        escaped = path.replace('"', '\\"')
+        return f'@"{escaped}"'
+    return f"@{path}"
+
+
+def _build_image_gen_prompt(args: dict[str, Any]) -> str:
+    prompt = str(args.get("prompt") or "").strip()
+    image_paths = args.get("image_paths")
+
+    lines: list[str] = ["Generate images: " + prompt]
+    if isinstance(image_paths, list) and image_paths:
+        referenced = [str(p) for p in cast(list[object], image_paths) if str(p).strip()]
+        if referenced:
+            lines.append("\n# Reference images\n" + "\n".join(_quote_at_pattern_path(p) for p in referenced))
+
+    return "\n".join(lines).strip()
+
+
+register_sub_agent(
+    SubAgentProfile(
+        name="ImageGen",
+        description=IMAGE_GEN_DESCRIPTION,
+        parameters=IMAGE_GEN_PARAMETERS,
+        prompt_file="prompts/prompt-sub-agent-image-gen.md",
+        tool_set=(),
+        prompt_builder=_build_image_gen_prompt,
+        active_form="Generating Image",
+    )
+)

klaude_code/protocol/sub_agent/task.py

@@ -24,11 +24,21 @@ Usage notes:
 Structured output:
 - Provide an `output_format` (JSON Schema) parameter for structured data back from the agent
 - Example: `output_format={"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "List of file paths that match the search criteria, e.g. ['src/main.py', 'src/utils/helper.py']"}}, "required": ["files"]}`\
+
+- 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.
 """
 
 TASK_PARAMETERS = {
     "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 task",

klaude_code/protocol/sub_agent/web.py

@@ -29,11 +29,21 @@ What you receive:
 - With `output_format`, you receive structured JSON matching your schema
 - The response is the agent's analysis, not raw web content
 - Web content is saved to local files (paths included in Sources) - read them directly if you need full content\
+
+- 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.
 """
 
 WEB_AGENT_PARAMETERS = {
     "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 task",

klaude_code/session/codec.py

@@ -5,7 +5,7 @@ from typing import Any, TypeGuard, cast, get_args
 
 from pydantic import BaseModel
 
-from klaude_code.protocol import model
+from klaude_code.protocol import message
 
 
 def _is_basemodel_subclass(tp: object) -> TypeGuard[type[BaseModel]]:
@@ -24,7 +24,7 @@ def _flatten_union(tp: object) -> list[object]:
 
 def _build_type_registry() -> dict[str, type[BaseModel]]:
     registry: dict[str, type[BaseModel]] = {}
-    for tp in _flatten_union(model.ConversationItem):
+    for tp in _flatten_union(message.HistoryEvent):
         if not _is_basemodel_subclass(tp):
             continue
         registry[tp.__name__] = tp
@@ -34,11 +34,11 @@ def _build_type_registry() -> dict[str, type[BaseModel]]:
 _CONVERSATION_ITEM_TYPES: dict[str, type[BaseModel]] = _build_type_registry()
 
 
-def encode_conversation_item(item: model.ConversationItem) -> dict[str, Any]:
+def encode_conversation_item(item: message.HistoryEvent) -> dict[str, Any]:
     return {"type": item.__class__.__name__, "data": item.model_dump(mode="json")}
 
 
-def decode_conversation_item(obj: dict[str, Any]) -> model.ConversationItem | None:
+def decode_conversation_item(obj: dict[str, Any]) -> message.HistoryEvent | None:
     t = obj.get("type")
     data = obj.get("data", {})
     if not isinstance(t, str) or not isinstance(data, dict):
@@ -54,11 +54,11 @@ def decode_conversation_item(obj: dict[str, Any]) -> model.ConversationItem | No
     return item  # type: ignore[return-value]
 
 
-def encode_jsonl_line(item: model.ConversationItem) -> str:
+def encode_jsonl_line(item: message.HistoryEvent) -> str:
     return json.dumps(encode_conversation_item(item), ensure_ascii=False) + "\n"
 
 
-def decode_jsonl_line(line: str) -> model.ConversationItem | None:
+def decode_jsonl_line(line: str) -> message.HistoryEvent | None:
     line = line.strip()
     if not line:
         return None