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

klaude_code/core/tool/sub_agent/task.py

@@ -0,0 +1,205 @@
+"""Task tool implementation for running sub-agents by type."""
+
+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, iter_sub_agent_profiles
+from klaude_code.session.session import Session
+
+TASK_TYPE_TO_SUB_AGENT: dict[str, str] = {
+    "general-purpose": "Task",
+    "explore": "Explore",
+    "web": "Web",
+}
+
+
+def _task_description() -> str:
+    summaries: dict[str, str] = {}
+    for profile in iter_sub_agent_profiles():
+        if profile.invoker_type:
+            summaries[profile.invoker_type] = profile.invoker_summary.strip()
+
+    type_lines: list[str] = []
+    for invoker_type in TASK_TYPE_TO_SUB_AGENT:
+        summary = summaries.get(invoker_type, "")
+        if summary:
+            type_lines.append(f"- {invoker_type}: {summary}")
+        else:
+            type_lines.append(f"- {invoker_type}")
+
+    types_section = "\n".join(type_lines) if type_lines else "- general-purpose"
+
+    return load_desc(Path(__file__).parent / "task.md", {"types_section": types_section})
+
+
+TASK_SCHEMA = llm_param.ToolSchema(
+    name=tools.TASK,
+    type="function",
+    description=_task_description(),
+    parameters={
+        "type": "object",
+        "properties": {
+            "type": {
+                "type": "string",
+                "enum": list(TASK_TYPE_TO_SUB_AGENT.keys()),
+                "description": "Sub-agent type selector.",
+            },
+            "description": {
+                "type": "string",
+                "description": "A short (3-5 word) description of the task.",
+            },
+            "prompt": {
+                "type": "string",
+                "description": "The task for the agent to perform.",
+            },
+            "output_schema": {
+                "type": "object",
+                "description": "Optional JSON Schema for structured output.",
+            },
+            "resume": {
+                "type": "string",
+                "description": "Optional agent ID to resume from.",
+            },
+        },
+        "required": ["description", "prompt"],
+        "additionalProperties": False,
+    },
+)
+
+
+@register(tools.TASK)
+class TaskTool(ToolABC):
+    """Run a sub-agent based on the requested type."""
+
+    @classmethod
+    def metadata(cls) -> ToolMetadata:
+        return ToolMetadata(concurrency_policy=ToolConcurrencyPolicy.CONCURRENT, has_side_effects=True)
+
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return TASK_SCHEMA
+
+    @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")
+
+        description = str(typed_args.get("description") or "")
+
+        resume_raw = typed_args.get("resume")
+        resume_session_id: str | None = None
+        resume_sub_agent_type: 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))
+
+            try:
+                resume_session = Session.load(resume_session_id)
+            except (OSError, ValueError, json.JSONDecodeError) as exc:
+                return message.ToolResultMessage(
+                    status="error",
+                    output_text=f"Failed to resume sub-agent session '{resume_session_id}': {exc}",
+                )
+
+            if resume_session.sub_agent_state is None:
+                return message.ToolResultMessage(
+                    status="error",
+                    output_text=f"Invalid resume id '{resume_session_id}': target session is not a sub-agent session",
+                )
+
+            resume_sub_agent_type = resume_session.sub_agent_state.sub_agent_type
+            if resume_sub_agent_type == tools.IMAGE_GEN:
+                return message.ToolResultMessage(
+                    status="error",
+                    output_text="This resume id belongs to ImageGen; use the ImageGen tool to resume it.",
+                )
+
+            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."
+                        ),
+                    )
+
+        type_raw = typed_args.get("type")
+        requested_type = str(type_raw).strip() if isinstance(type_raw, str) else ""
+
+        if resume_session_id and not requested_type:
+            sub_agent_type = resume_sub_agent_type or TASK_TYPE_TO_SUB_AGENT["general-purpose"]
+        else:
+            if not requested_type:
+                requested_type = "general-purpose"
+            sub_agent_type = TASK_TYPE_TO_SUB_AGENT.get(requested_type)
+            if sub_agent_type is None:
+                return message.ToolResultMessage(
+                    status="error",
+                    output_text=f"Unknown Task type '{requested_type}'.",
+                )
+
+        if resume_session_id and resume_sub_agent_type and resume_sub_agent_type != sub_agent_type:
+            return message.ToolResultMessage(
+                status="error",
+                output_text=(
+                    "Invalid resume id: sub-agent type mismatch. "
+                    f"Expected '{sub_agent_type}', got '{resume_sub_agent_type}'."
+                ),
+            )
+
+        try:
+            profile = get_sub_agent_profile(sub_agent_type)
+        except KeyError as exc:
+            return message.ToolResultMessage(status="error", output_text=str(exc))
+
+        sub_agent_prompt = profile.prompt_builder(typed_args)
+
+        output_schema_raw = typed_args.get("output_schema")
+        output_schema = cast(dict[str, Any], output_schema_raw) if isinstance(output_schema_raw, dict) else None
+
+        try:
+            result = await runner(
+                model.SubAgentState(
+                    sub_agent_type=profile.name,
+                    sub_agent_desc=description,
+                    sub_agent_prompt=sub_agent_prompt,
+                    resume=resume_session_id,
+                    output_schema=output_schema,
+                    generation=None,
+                ),
+                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/tool_registry.py

@@ -1,10 +1,8 @@
 from collections.abc import Callable
 from typing import TypeVar
 
-from klaude_code.core.tool.sub_agent_tool import SubAgentTool
 from klaude_code.core.tool.tool_abc import ToolABC
 from klaude_code.protocol import llm_param
-from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 
 _REGISTRY: dict[str, type[ToolABC]] = {}
 
@@ -19,20 +17,6 @@ def register(name: str) -> Callable[[type[T]], type[T]]:
     return _decorator
 
 
-def _register_sub_agent_tools() -> None:
-    """Automatically register all sub-agent tools based on their profiles."""
-    for profile in iter_sub_agent_profiles():
-        tool_cls = SubAgentTool.for_profile(profile)
-        _REGISTRY[profile.name] = tool_cls
-
-
-_register_sub_agent_tools()
-
-
-def list_tools() -> list[str]:
-    return list(_REGISTRY.keys())
-
-
 def get_tool_schemas(tool_names: list[str]) -> list[llm_param.ToolSchema]:
     schemas: list[llm_param.ToolSchema] = []
     for tool_name in tool_names:

klaude_code/core/turn.py

@@ -243,7 +243,7 @@ class TurnExecutor:
         )
 
         # ImageGen per-call overrides (tool-level `generation` parameters)
-        if ctx.sub_agent_state is not None and ctx.sub_agent_state.sub_agent_type == "ImageGen":
+        if ctx.sub_agent_state is not None and ctx.sub_agent_state.sub_agent_type == tools.IMAGE_GEN:
             call_param.modalities = ["image", "text"]
             generation = ctx.sub_agent_state.generation or {}
             image_config = llm_param.ImageConfig()

klaude_code/llm/anthropic/input.py

@@ -18,9 +18,10 @@ from anthropic.types.beta.beta_tool_use_block_param import BetaToolUseBlockParam
 from anthropic.types.beta.beta_url_image_source_param import BetaURLImageSourceParam
 
 from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
-from klaude_code.llm.image import parse_data_url
+from klaude_code.llm.image import 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,
@@ -36,8 +37,8 @@ _INLINE_IMAGE_MEDIA_TYPES: tuple[AllowedMediaType, ...] = (
 )
 
 
-def _image_part_to_block(image: message.ImageURLPart) -> BetaImageBlockParam:
-    url = image.url
+def _image_part_to_block(image: ImagePart) -> BetaImageBlockParam:
+    url = image_file_to_data_url(image) if isinstance(image, message.ImageFilePart) else image.url
     if url.startswith("data:"):
         media_type, base64_payload, _ = parse_data_url(url)
         if media_type not in _INLINE_IMAGE_MEDIA_TYPES:
@@ -64,7 +65,7 @@ def _user_message_to_message(
     for part in msg.parts:
         if isinstance(part, message.TextPart):
             blocks.append(cast(BetaTextBlockParam, {"type": "text", "text": part.text}))
-        elif isinstance(part, message.ImageURLPart):
+        elif isinstance(part, (message.ImageURLPart, message.ImageFilePart)):
             blocks.append(_image_part_to_block(part))
     if attachment.text:
         blocks.append(cast(BetaTextBlockParam, {"type": "text", "text": attachment.text}))
@@ -86,7 +87,7 @@ def _tool_message_to_block(
         attachment.text,
     )
     tool_content.append(cast(BetaTextBlockParam, {"type": "text", "text": merged_text}))
-    for image in [part for part in msg.parts if isinstance(part, message.ImageURLPart)]:
+    for image in [part for part in msg.parts if isinstance(part, (message.ImageURLPart, message.ImageFilePart))]:
         tool_content.append(_image_part_to_block(image))
     for image in attachment.images:
         tool_content.append(_image_part_to_block(image))

klaude_code/llm/antigravity/input.py

@@ -6,9 +6,10 @@ from binascii import Error as BinasciiError
 from typing import Any, TypedDict
 
 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,
@@ -66,9 +67,9 @@ def _data_url_to_inline_data(url: str) -> InlineData:
     return InlineData(mimeType=media_type, data=base64.b64encode(decoded).decode("ascii"))
 
 
-def _image_part_to_part(image: message.ImageURLPart) -> Part:
-    """Convert ImageURLPart to Part dict."""
-    url = image.url
+def _image_part_to_part(image: ImagePart) -> Part:
+    """Convert ImageURLPart or ImageFilePart to Part dict."""
+    url = image_file_to_data_url(image) if isinstance(image, message.ImageFilePart) else image.url
     if url.startswith("data:"):
         return Part(inlineData=_data_url_to_inline_data(url))
     # For non-data URLs, best-effort using inline_data format
@@ -81,7 +82,7 @@ def _user_message_to_content(msg: message.UserMessage, attachment: DeveloperAtta
     for part in msg.parts:
         if isinstance(part, message.TextPart):
             parts.append(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(Part(text=attachment.text))
@@ -108,14 +109,20 @@ 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[Part] = []
         function_response_parts: list[dict[str, Any]] = []
 
         for image in images:
             try:
                 image_parts.append(_image_part_to_part(image))
-                if image.url.startswith("data:"):
+                if isinstance(image, message.ImageFilePart):
+                    inline_data = _data_url_to_inline_data(image_file_to_data_url(image))
+                    function_response_parts.append({"inlineData": inline_data})
+                elif image.url.startswith("data:"):
                     inline_data = _data_url_to_inline_data(image.url)
                     function_response_parts.append({"inlineData": inline_data})
             except ValueError:

klaude_code/llm/bedrock_anthropic/__init__.py

@@ -0,0 +1,3 @@
+from klaude_code.llm.bedrock_anthropic.client import BedrockClient
+
+__all__ = ["BedrockClient"]

klaude_code/llm/google/client.py

@@ -3,7 +3,6 @@
 # pyright: reportUnknownArgumentType=false
 # pyright: reportAttributeAccessIssue=false
 
-import json
 from base64 import b64encode
 from collections.abc import AsyncGenerator, AsyncIterator
 from typing import Any, cast, override
@@ -33,6 +32,7 @@ from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.google.input import convert_history_to_contents, convert_tool_schema
 from klaude_code.llm.image import save_assistant_image
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.json_stable import dumps_canonical_json
 from klaude_code.llm.registry import register
 from klaude_code.llm.stream_parts import (
     append_text_part,
@@ -122,6 +122,8 @@ def _usage_from_metadata(
     if usage is None:
         return None
 
+    # In Gemini usage metadata, prompt_token_count represents the full prompt tokens
+    # (including cached tokens). cached_content_token_count is a subset of prompt tokens.
     cached = usage.cached_content_token_count or 0
     prompt = usage.prompt_token_count or 0
     response = usage.candidates_token_count or 0
@@ -136,10 +138,10 @@ def _usage_from_metadata(
 
     total = usage.total_token_count
     if total is None:
-        total = prompt + cached + response + thoughts
+        total = prompt + response + thoughts
 
     return model.Usage(
-        input_tokens=prompt + cached,
+        input_tokens=prompt,
         cached_tokens=cached,
         output_tokens=response + thoughts,
         reasoning_tokens=thoughts,
@@ -385,7 +387,7 @@ async def parse_google_stream(
             args_obj = function_call.args
             if args_obj is not None:
                 # Add ToolCallPart, then ThinkingSignaturePart after it
-                state.append_tool_call(call_id, name, json.dumps(args_obj, ensure_ascii=False))
+                state.append_tool_call(call_id, name, dumps_canonical_json(args_obj))
                 encoded_sig = _encode_thought_signature(thought_signature)
                 if encoded_sig:
                     state.append_thinking_signature(encoded_sig)
@@ -400,7 +402,7 @@ async def parse_google_stream(
             will_continue = function_call.will_continue
             if will_continue is False and call_id in partial_args_by_call and call_id not in completed_tool_items:
                 # Add ToolCallPart, then ThinkingSignaturePart after it
-                state.append_tool_call(call_id, name, json.dumps(partial_args_by_call[call_id], ensure_ascii=False))
+                state.append_tool_call(call_id, name, dumps_canonical_json(partial_args_by_call[call_id]))
                 stored_sig = started_tool_calls.get(call_id, (name, None))[1]
                 encoded_stored_sig = _encode_thought_signature(stored_sig)
                 if encoded_stored_sig:
@@ -412,7 +414,7 @@ async def parse_google_stream(
         if call_id in completed_tool_items:
             continue
         args = partial_args_by_call.get(call_id, {})
-        state.append_tool_call(call_id, name, json.dumps(args, ensure_ascii=False))
+        state.append_tool_call(call_id, name, dumps_canonical_json(args))
         encoded_stored_sig = _encode_thought_signature(stored_sig)
         if encoded_stored_sig:
             state.append_thinking_signature(encoded_stored_sig)

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
@@ -141,6 +149,14 @@ def build_assistant_common_fields(
             }
             for tc in tool_calls
         ]
+
+    thinking_parts = [part for part in msg.parts if isinstance(part, message.ThinkingTextPart)]
+    if thinking_parts:
+        thinking_text = "".join(part.text for part in thinking_parts)
+        reasoning_field = next((p.reasoning_field for p in thinking_parts if p.reasoning_field), None)
+        if thinking_text and reasoning_field:
+            result[reasoning_field] = thinking_text
+
     return result
 
 
@@ -177,4 +193,14 @@ def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter
         param.verbosity = config.verbosity
     if param.thinking is None:
         param.thinking = config.thinking
+    if param.modalities is None:
+        param.modalities = config.modalities
+    if param.image_config is None:
+        param.image_config = config.image_config
+    elif config.image_config is not None:
+        # Merge field-level: param overrides config defaults
+        if param.image_config.aspect_ratio is None:
+            param.image_config.aspect_ratio = config.image_config.aspect_ratio
+        if param.image_config.image_size is None:
+            param.image_config.image_size = config.image_config.image_size
     return param

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)