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

klaude_code/llm/google/input.py

@@ -6,18 +6,20 @@
 import json
 from base64 import b64decode
 from binascii import Error as BinasciiError
-from typing import Any
+from typing import Any, cast
 
 from google.genai import types
 
 from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
-from klaude_code.llm.image import assistant_image_to_data_url, parse_data_url
+from klaude_code.llm.image import assistant_image_to_data_url, image_file_to_data_url, parse_data_url
 from klaude_code.llm.input_common import (
     DeveloperAttachment,
+    ImagePart,
     attach_developer_messages,
     merge_reminder_text,
     split_thinking_parts,
 )
+from klaude_code.llm.json_stable import canonicalize_json
 from klaude_code.protocol import llm_param, message
 
 
@@ -26,16 +28,16 @@ def _data_url_to_blob(url: str) -> types.Blob:
     return types.Blob(data=decoded, mime_type=media_type)
 
 
-def _image_part_to_part(image: message.ImageURLPart) -> types.Part:
-    url = image.url
+def _image_part_to_part(image: ImagePart) -> types.Part:
+    url = image_file_to_data_url(image) if isinstance(image, message.ImageFilePart) else image.url
     if url.startswith("data:"):
         return types.Part(inline_data=_data_url_to_blob(url))
     # Best-effort: Gemini supports file URIs, and may accept public HTTPS URLs.
     return types.Part(file_data=types.FileData(file_uri=url))
 
 
-def _image_part_to_function_response_part(image: message.ImageURLPart) -> types.FunctionResponsePart:
-    url = image.url
+def _image_part_to_function_response_part(image: ImagePart) -> types.FunctionResponsePart:
+    url = image_file_to_data_url(image) if isinstance(image, message.ImageFilePart) else image.url
     if url.startswith("data:"):
         media_type, _, decoded = parse_data_url(url)
         return types.FunctionResponsePart.from_bytes(data=decoded, mime_type=media_type)
@@ -47,7 +49,7 @@ def _user_message_to_content(msg: message.UserMessage, attachment: DeveloperAtta
     for part in msg.parts:
         if isinstance(part, message.TextPart):
             parts.append(types.Part(text=part.text))
-        elif isinstance(part, message.ImageURLPart):
+        elif isinstance(part, (message.ImageURLPart, message.ImageFilePart)):
             parts.append(_image_part_to_part(part))
     if attachment.text:
         parts.append(types.Part(text=attachment.text))
@@ -73,7 +75,10 @@ def _tool_messages_to_contents(
         )
         has_text = merged_text.strip() != ""
 
-        images = [part for part in msg.parts if isinstance(part, message.ImageURLPart)] + attachment.images
+        images: list[ImagePart] = [
+            part for part in msg.parts if isinstance(part, (message.ImageURLPart, message.ImageFilePart))
+        ]
+        images.extend(attachment.images)
         image_parts: list[types.Part] = []
         function_response_parts: list[types.FunctionResponsePart] = []
 
@@ -155,11 +160,14 @@ def _assistant_message_to_content(msg: message.AssistantMessage, model_name: str
             args: dict[str, Any]
             if part.arguments_json:
                 try:
-                    args = json.loads(part.arguments_json)
+                    loaded: object = json.loads(part.arguments_json)
                 except json.JSONDecodeError:
-                    args = {"_raw": part.arguments_json}
+                    loaded = {"_raw": part.arguments_json}
             else:
-                args = {}
+                loaded = {}
+
+            canonical = canonicalize_json(loaded)
+            args = cast(dict[str, Any], canonical) if isinstance(canonical, dict) else {"_value": canonical}
             parts.append(
                 types.Part(
                     function_call=types.FunctionCall(id=part.call_id, name=part.tool_name, args=args),
@@ -223,7 +231,7 @@ def convert_tool_schema(tools: list[llm_param.ToolSchema] | None) -> list[types.
         types.FunctionDeclaration(
             name=tool.name,
             description=tool.description,
-            parameters_json_schema=tool.parameters,
+            parameters_json_schema=canonicalize_json(tool.parameters),
         )
         for tool in tools
     ]

klaude_code/llm/image.py

@@ -99,21 +99,12 @@ def save_assistant_image(
     )
 
 
-def assistant_image_to_data_url(image: message.ImageFilePart) -> str:
-    """Load an assistant image from disk and encode it as a base64 data URL.
-
-    This is primarily used for multi-turn image editing, where providers require
-    sending the previous assistant message (including images) back to the model.
-    """
+def image_file_to_data_url(image: message.ImageFilePart) -> str:
+    """Load an image file from disk and encode it as a base64 data URL."""
 
     file_path = Path(image.file_path)
     decoded = file_path.read_bytes()
 
-    if len(decoded) > IMAGE_OUTPUT_MAX_BYTES:
-        decoded_mb = len(decoded) / (1024 * 1024)
-        limit_mb = IMAGE_OUTPUT_MAX_BYTES / (1024 * 1024)
-        raise ValueError(f"Assistant image size ({decoded_mb:.2f}MB) exceeds limit ({limit_mb:.2f}MB)")
-
     mime_type = image.mime_type
     if not mime_type:
         guessed, _ = mimetypes.guess_type(str(file_path))
@@ -121,3 +112,19 @@ def assistant_image_to_data_url(image: message.ImageFilePart) -> str:
 
     encoded = b64encode(decoded).decode("ascii")
     return f"data:{mime_type};base64,{encoded}"
+
+
+def assistant_image_to_data_url(image: message.ImageFilePart) -> str:
+    """Load an assistant image from disk and encode it as a base64 data URL.
+
+    This is primarily used for multi-turn image editing, where providers require
+    sending the previous assistant message (including images) back to the model.
+    """
+
+    file_path = Path(image.file_path)
+    if file_path.stat().st_size > IMAGE_OUTPUT_MAX_BYTES:
+        size_mb = file_path.stat().st_size / (1024 * 1024)
+        limit_mb = IMAGE_OUTPUT_MAX_BYTES / (1024 * 1024)
+        raise ValueError(f"Assistant image size ({size_mb:.2f}MB) exceeds limit ({limit_mb:.2f}MB)")
+
+    return image_file_to_data_url(image)

klaude_code/llm/input_common.py

@@ -8,26 +8,29 @@ if TYPE_CHECKING:
     from klaude_code.protocol.llm_param import LLMCallParameter, LLMConfigParameter
 
 from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.image import image_file_to_data_url
 from klaude_code.protocol import message
 
+ImagePart = message.ImageURLPart | message.ImageFilePart
 
-def _empty_image_parts() -> list[message.ImageURLPart]:
+
+def _empty_image_parts() -> list[ImagePart]:
     return []
 
 
 @dataclass
 class DeveloperAttachment:
     text: str = ""
-    images: list[message.ImageURLPart] = field(default_factory=_empty_image_parts)
+    images: list[ImagePart] = field(default_factory=_empty_image_parts)
 
 
-def _extract_developer_content(msg: message.DeveloperMessage) -> tuple[str, list[message.ImageURLPart]]:
+def _extract_developer_content(msg: message.DeveloperMessage) -> tuple[str, list[ImagePart]]:
     text_parts: list[str] = []
-    images: list[message.ImageURLPart] = []
+    images: list[ImagePart] = []
     for part in msg.parts:
         if isinstance(part, message.TextPart):
             text_parts.append(part.text + "\n")
-        elif isinstance(part, message.ImageURLPart):
+        elif isinstance(part, (message.ImageURLPart, message.ImageFilePart)):
             images.append(part)
     return "".join(text_parts), images
 
@@ -87,10 +90,15 @@ def build_chat_content_parts(
             parts.append({"type": "text", "text": part.text})
         elif isinstance(part, message.ImageURLPart):
             parts.append({"type": "image_url", "image_url": {"url": part.url}})
+        elif isinstance(part, message.ImageFilePart):
+            parts.append({"type": "image_url", "image_url": {"url": image_file_to_data_url(part)}})
     if attachment.text:
         parts.append({"type": "text", "text": attachment.text})
     for image in attachment.images:
-        parts.append({"type": "image_url", "image_url": {"url": image.url}})
+        if isinstance(image, message.ImageFilePart):
+            parts.append({"type": "image_url", "image_url": {"url": image_file_to_data_url(image)}})
+        else:
+            parts.append({"type": "image_url", "image_url": {"url": image.url}})
     if not parts:
         parts.append({"type": "text", "text": ""})
     return parts

klaude_code/llm/json_stable.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import cast
+
+type JsonValue = str | int | float | bool | None | list["JsonValue"] | dict[str, "JsonValue"]
+
+
+def canonicalize_json(value: object) -> JsonValue:
+    """Return a JSON-equivalent value with stable dict key ordering.
+
+    This is used to make provider payload serialization stable across runs so that
+    prefix caching has a better chance to hit.
+    """
+
+    if isinstance(value, Mapping):
+        items: list[tuple[str, JsonValue]] = []
+        for key, item_value in cast(Mapping[object, object], value).items():
+            items.append((str(key), canonicalize_json(item_value)))
+        items.sort(key=lambda kv: kv[0])
+        return {k: v for k, v in items}
+
+    if isinstance(value, list):
+        return [canonicalize_json(v) for v in cast(list[object], value)]
+
+    if isinstance(value, tuple):
+        return [canonicalize_json(v) for v in cast(tuple[object, ...], value)]
+
+    return cast(JsonValue, value)
+
+
+def dumps_canonical_json(value: object) -> str:
+    """Dump JSON with stable key order and no insignificant whitespace."""
+
+    canonical = canonicalize_json(value)
+    return json.dumps(canonical, ensure_ascii=False, separators=(",", ":"), sort_keys=False)

klaude_code/llm/openai_compatible/input.py

@@ -6,7 +6,6 @@
 from typing import cast
 
 from openai.types import chat
-from openai.types.chat import ChatCompletionContentPartParam
 
 from klaude_code.llm.image import assistant_image_to_data_url
 from klaude_code.llm.input_common import (
@@ -30,15 +29,6 @@ def _assistant_message_to_openai(msg: message.AssistantMessage) -> chat.ChatComp
     return cast(chat.ChatCompletionMessageParam, assistant_message)
 
 
-def build_user_content_parts(
-    images: list[message.ImageURLPart],
-) -> list[ChatCompletionContentPartParam]:
-    """Build content parts for images only. Used by OpenRouter."""
-    return [
-        cast(ChatCompletionContentPartParam, {"type": "image_url", "image_url": {"url": image.url}}) for image in images
-    ]
-
-
 def convert_history_to_input(
     history: list[message.Message],
     system: str | None = None,

klaude_code/llm/openai_compatible/stream.py

@@ -12,6 +12,7 @@ how reasoning is represented (``reasoning_details`` vs ``reasoning_content``).
 
 from __future__ import annotations
 
+import re
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, Callable
 from dataclasses import dataclass
@@ -26,7 +27,6 @@ from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 from klaude_code.llm.client import LLMStreamABC
 from klaude_code.llm.image import save_assistant_image
-from klaude_code.llm.openai_compatible.tool_call_accumulator import normalize_tool_name
 from klaude_code.llm.stream_parts import (
     append_text_part,
     append_thinking_text_part,
@@ -34,9 +34,24 @@ from klaude_code.llm.stream_parts import (
     build_partial_parts,
 )
 from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.log import log_debug
 from klaude_code.protocol import llm_param, message, model
 
 
+def normalize_tool_name(name: str) -> str:
+    """Normalize tool name from Gemini-3 format.
+
+    Gemini-3 sometimes returns tool names in format like 'tool_Edit_mUoY2p3W3r3z8uO5P2nZ'.
+    This function extracts the actual tool name (e.g., 'Edit').
+    """
+    match = re.match(r"^tool_([A-Za-z]+)_[A-Za-z0-9]+$", name)
+    if match:
+        normalized = match.group(1)
+        log_debug(f"Gemini-3 tool name normalized: {name} -> {normalized}", style="yellow")
+        return normalized
+    return name
+
+
 class StreamStateManager:
     """Manages streaming state and accumulates parts in stream order.
 

klaude_code/llm/registry.py

@@ -38,11 +38,6 @@ def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
     _loaded_protocols.add(protocol)
 
 
-def load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
-    """Load the module for a specific protocol on demand."""
-    _load_protocol(protocol)
-
-
 def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:
     """Decorator to register an LLM client class for a protocol."""
 

klaude_code/llm/responses/input.py

@@ -7,6 +7,7 @@ from typing import Any, cast
 from openai.types import responses
 
 from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.image import image_file_to_data_url
 from klaude_code.llm.input_common import (
     DeveloperAttachment,
     attach_developer_messages,
@@ -16,6 +17,12 @@ from klaude_code.llm.input_common import (
 from klaude_code.protocol import llm_param, message
 
 
+def _image_to_url(image: message.ImageURLPart | message.ImageFilePart) -> str:
+    if isinstance(image, message.ImageFilePart):
+        return image_file_to_data_url(image)
+    return image.url
+
+
 def _build_user_content_parts(
     user: message.UserMessage,
     attachment: DeveloperAttachment,
@@ -24,11 +31,11 @@ def _build_user_content_parts(
     for part in user.parts:
         if isinstance(part, message.TextPart):
             parts.append(cast(responses.ResponseInputContentParam, {"type": "input_text", "text": part.text}))
-        elif isinstance(part, message.ImageURLPart):
+        elif isinstance(part, (message.ImageURLPart, message.ImageFilePart)):
             parts.append(
                 cast(
                     responses.ResponseInputContentParam,
-                    {"type": "input_image", "detail": "auto", "image_url": part.url},
+                    {"type": "input_image", "detail": "auto", "image_url": _image_to_url(part)},
                 )
             )
     if attachment.text:
@@ -37,7 +44,7 @@ def _build_user_content_parts(
         parts.append(
             cast(
                 responses.ResponseInputContentParam,
-                {"type": "input_image", "detail": "auto", "image_url": image.url},
+                {"type": "input_image", "detail": "auto", "image_url": _image_to_url(image)},
             )
         )
     if not parts:
@@ -56,12 +63,15 @@ def _build_tool_result_item(
     )
     if text_output:
         content_parts.append(cast(responses.ResponseInputContentParam, {"type": "input_text", "text": text_output}))
-    images = [part for part in tool.parts if isinstance(part, message.ImageURLPart)] + attachment.images
+    images: list[message.ImageURLPart | message.ImageFilePart] = [
+        part for part in tool.parts if isinstance(part, (message.ImageURLPart, message.ImageFilePart))
+    ]
+    images.extend(attachment.images)
     for image in images:
         content_parts.append(
             cast(
                 responses.ResponseInputContentParam,
-                {"type": "input_image", "detail": "auto", "image_url": image.url},
+                {"type": "input_image", "detail": "auto", "image_url": _image_to_url(image)},
             )
         )
 

klaude_code/llm/usage.py

@@ -44,14 +44,6 @@ class MetadataTracker:
         self._usage = model.Usage()
         self._cost_config = cost_config
 
-    @property
-    def first_token_time(self) -> float | None:
-        return self._first_token_time
-
-    @property
-    def last_token_time(self) -> float | None:
-        return self._last_token_time
-
     def record_token(self) -> None:
         """Record a token arrival, updating first/last token times."""
         now = time.time()

klaude_code/protocol/commands.py

@@ -27,6 +27,7 @@ class CommandName(str, Enum):
     FORK_SESSION = "fork-session"
     RESUME = "resume"
     COPY = "copy"
+    CONTINUE = "continue"
 
     def __str__(self) -> str:
         return self.value

klaude_code/protocol/events.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import time
+from collections.abc import Sequence
 from typing import Literal
 
 from pydantic import BaseModel, Field
@@ -58,7 +59,7 @@ class ResponseEvent(Event):
 
 class UserMessageEvent(Event):
     content: str
-    images: list[message.ImageURLPart] | None = None
+    images: Sequence[message.ImageURLPart | message.ImageFilePart] | None = None
 
 
 class DeveloperMessageEvent(Event):

klaude_code/protocol/message.py

@@ -213,7 +213,7 @@ class UserInputPayload(BaseModel):
     """
 
     text: str
-    images: list[ImageURLPart] | None = None
+    images: Sequence[ImageURLPart | ImageFilePart] | None = None
 
 
 # Helper functions
@@ -225,7 +225,7 @@ def text_parts_from_str(text: str | None) -> list[Part]:
     return [TextPart(text=text)]
 
 
-def parts_from_text_and_images(text: str | None, images: list[ImageURLPart] | None) -> list[Part]:
+def parts_from_text_and_images(text: str | None, images: Sequence[ImageURLPart | ImageFilePart] | None) -> list[Part]:
     parts: list[Part] = []
     if text:
         parts.append(TextPart(text=text))

klaude_code/protocol/model.py

@@ -217,6 +217,11 @@ class MermaidLinkUIExtra(BaseModel):
     line_count: int
 
 
+class ImageUIExtra(BaseModel):
+    type: Literal["image"] = "image"
+    file_path: str
+
+
 class MarkdownDocUIExtra(BaseModel):
     type: Literal["markdown_doc"] = "markdown_doc"
     file_path: str
@@ -231,7 +236,13 @@ class SessionStatusUIExtra(BaseModel):
 
 
 MultiUIExtraItem = (
-    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | MarkdownDocUIExtra | SessionStatusUIExtra
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | ImageUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra
 )
 
 
@@ -251,6 +262,7 @@ ToolResultUIExtra = Annotated[
     | TodoListUIExtra
     | SessionIdUIExtra
     | MermaidLinkUIExtra
+    | ImageUIExtra
     | MarkdownDocUIExtra
     | SessionStatusUIExtra
     | MultiUIExtra,
@@ -292,6 +304,7 @@ class AtFileOpsUIItem(BaseModel):
 class UserImagesUIItem(BaseModel):
     type: Literal["user_images"] = "user_images"
     count: int
+    paths: list[str] = []
 
 
 class SkillActivatedUIItem(BaseModel):
@@ -299,6 +312,11 @@ class SkillActivatedUIItem(BaseModel):
     name: str
 
 
+class AtFileImagesUIItem(BaseModel):
+    type: Literal["at_file_images"] = "at_file_images"
+    paths: list[str]
+
+
 type DeveloperUIItem = (
     MemoryLoadedUIItem
     | ExternalFileChangesUIItem
@@ -306,6 +324,7 @@ type DeveloperUIItem = (
     | AtFileOpsUIItem
     | UserImagesUIItem
     | SkillActivatedUIItem
+    | AtFileImagesUIItem
 )
 
 

klaude_code/protocol/op.py

@@ -24,8 +24,10 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     RUN_AGENT = "run_agent"
+    CONTINUE_AGENT = "continue_agent"
     COMPACT_SESSION = "compact_session"
     CHANGE_MODEL = "change_model"
+    CHANGE_COMPACT_MODEL = "change_compact_model"
     CHANGE_SUB_AGENT_MODEL = "change_sub_agent_model"
     CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
@@ -58,6 +60,19 @@ class RunAgentOperation(Operation):
         await handler.handle_run_agent(self)
 
 
+class ContinueAgentOperation(Operation):
+    """Operation for continuing an agent task without adding a new user message.
+
+    Used for recovery after interruptions (network errors, API failures, etc.).
+    """
+
+    type: OperationType = OperationType.CONTINUE_AGENT
+    session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_continue_agent(self)
+
+
 class CompactSessionOperation(Operation):
     """Operation for compacting a session's conversation history."""
 
@@ -94,6 +109,18 @@ class ChangeModelOperation(Operation):
         await handler.handle_change_model(self)
 
 
+class ChangeCompactModelOperation(Operation):
+    """Operation for changing the compact model (used for session compaction)."""
+
+    type: OperationType = OperationType.CHANGE_COMPACT_MODEL
+    session_id: str
+    model_name: str | None
+    save_as_default: bool = False
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_compact_model(self)
+
+
 class ChangeThinkingOperation(Operation):
     """Operation for changing the thinking/reasoning configuration."""
 

klaude_code/protocol/op_handler.py

@@ -10,11 +10,13 @@ from typing import TYPE_CHECKING, Protocol
 
 if TYPE_CHECKING:
     from klaude_code.protocol.op import (
+        ChangeCompactModelOperation,
         ChangeModelOperation,
         ChangeSubAgentModelOperation,
         ChangeThinkingOperation,
         ClearSessionOperation,
         CompactSessionOperation,
+        ContinueAgentOperation,
         ExportSessionOperation,
         InitAgentOperation,
         InterruptOperation,
@@ -30,6 +32,10 @@ class OperationHandler(Protocol):
         """Handle a run agent operation."""
         ...
 
+    async def handle_continue_agent(self, operation: ContinueAgentOperation) -> None:
+        """Handle a continue agent operation (resume without adding user message)."""
+        ...
+
     async def handle_compact_session(self, operation: CompactSessionOperation) -> None:
         """Handle a compact session operation."""
         ...
@@ -38,6 +44,10 @@ class OperationHandler(Protocol):
         """Handle a change model operation."""
         ...
 
+    async def handle_change_compact_model(self, operation: ChangeCompactModelOperation) -> None:
+        """Handle a change compact model operation."""
+        ...
+
     async def handle_change_thinking(self, operation: ChangeThinkingOperation) -> None:
         """Handle a change thinking operation."""
         ...

klaude_code/protocol/sub_agent/AGENTS.md

@@ -1,6 +1,6 @@
 # Sub-Agent Protocol
 
-Sub-agents are specialized agents invoked by the main agent as tools. This module defines profiles and registration.
+Sub-agents are specialized agent types invoked by tools like Task and ImageGen. This module defines profiles and registration.
 
 ## Key Constraint
 
@@ -9,7 +9,7 @@ The `protocol` layer cannot import from `config` or `core` (enforced by import-l
 ## Core Files
 
 - `__init__.py` - `SubAgentProfile` dataclass and registration. Defines `AVAILABILITY_*` constants.
-- `image_gen.py`, `task.py`, `explore.py`, `web.py` - Individual sub-agent definitions.
+- `image_gen.py`, `task.py`, `explore.py`, `web.py` - Individual sub-agent type definitions.
 
 ## Availability Requirement Flow
 
@@ -23,6 +23,6 @@ Some sub-agents require specific model capabilities (e.g., ImageGen needs an ima
 ## Model Selection
 
 For sub-agents with `availability_requirement`, priority is:
-1. Explicit config in `sub_agent_models`
-2. Auto-resolve via requirement
-3. If neither found, sub-agent is unavailable (no fallback to main agent model)
+1. Explicit config in `sub_agent_models` for the specific type
+2. Fallback to the Task model config (if present)
+3. Otherwise inherit the main agent model