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

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/codex/client.py

@@ -146,6 +146,28 @@ class CodexClient(LLMClientABC):
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
             error_message = f"{e.__class__.__name__} {e!s}"
+
+            # Check for invalid instruction error and invalidate prompt cache
+            if _is_invalid_instruction_error(e) and param.model_id:
+                _invalidate_prompt_cache_for_model(param.model_id)
+
             return error_llm_stream(metadata_tracker, error=error_message)
 
         return ResponsesLLMStream(stream, param=param, metadata_tracker=metadata_tracker)
+
+
+def _is_invalid_instruction_error(e: Exception) -> bool:
+    """Check if the error is related to invalid instructions."""
+    error_str = str(e).lower()
+    return "invalid instruction" in error_str or "invalid_instruction" in error_str
+
+
+def _invalidate_prompt_cache_for_model(model_id: str) -> None:
+    """Invalidate the cached prompt for a model to force refresh."""
+    from klaude_code.llm.codex.prompt_sync import invalidate_cache
+
+    log_debug(
+        f"Invalidating prompt cache for model {model_id} due to invalid instruction error",
+        debug_type=DebugType.GENERAL,
+    )
+    invalidate_cache(model_id)

klaude_code/llm/codex/prompt_sync.py

@@ -0,0 +1,237 @@
+"""Dynamic prompt synchronization from OpenAI Codex GitHub repository."""
+
+import json
+import time
+from functools import cache
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Literal
+
+import httpx
+
+from klaude_code.log import DebugType, log_debug
+
+GITHUB_API_RELEASES = "https://api.github.com/repos/openai/codex/releases/latest"
+GITHUB_HTML_RELEASES = "https://github.com/openai/codex/releases/latest"
+GITHUB_RAW_BASE = "https://raw.githubusercontent.com/openai/codex"
+
+CACHE_DIR = Path.home() / ".klaude" / "codex-prompts"
+CACHE_TTL_SECONDS = 24 * 60 * 60  # 24 hours
+
+type ModelFamily = Literal["gpt-5.2-codex", "codex-max", "codex", "gpt-5.2", "gpt-5.1"]
+
+PROMPT_FILES: dict[ModelFamily, str] = {
+    "gpt-5.2-codex": "gpt-5.2-codex_prompt.md",
+    "codex-max": "gpt-5.1-codex-max_prompt.md",
+    "codex": "gpt_5_codex_prompt.md",
+    "gpt-5.2": "gpt_5_2_prompt.md",
+    "gpt-5.1": "gpt_5_1_prompt.md",
+}
+
+CACHE_FILES: dict[ModelFamily, str] = {
+    "gpt-5.2-codex": "gpt-5.2-codex-instructions.md",
+    "codex-max": "codex-max-instructions.md",
+    "codex": "codex-instructions.md",
+    "gpt-5.2": "gpt-5.2-instructions.md",
+    "gpt-5.1": "gpt-5.1-instructions.md",
+}
+
+
+@cache
+def _load_bundled_prompt(prompt_path: str) -> str:
+    """Load bundled prompt from package resources."""
+    return files("klaude_code.core").joinpath(prompt_path).read_text(encoding="utf-8").strip()
+
+
+class CacheMetadata:
+    def __init__(self, etag: str | None, tag: str, last_checked: int, url: str):
+        self.etag = etag
+        self.tag = tag
+        self.last_checked = last_checked
+        self.url = url
+
+    def to_dict(self) -> dict[str, str | int | None]:
+        return {
+            "etag": self.etag,
+            "tag": self.tag,
+            "last_checked": self.last_checked,
+            "url": self.url,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, object]) -> "CacheMetadata":
+        etag = data.get("etag")
+        last_checked = data.get("last_checked")
+        return cls(
+            etag=etag if isinstance(etag, str) else None,
+            tag=str(data.get("tag", "")),
+            last_checked=int(last_checked) if isinstance(last_checked, int | float) else 0,
+            url=str(data.get("url", "")),
+        )
+
+
+def get_model_family(model: str) -> ModelFamily:
+    """Determine model family from model name."""
+    if "gpt-5.2-codex" in model or "gpt 5.2 codex" in model:
+        return "gpt-5.2-codex"
+    if "codex-max" in model:
+        return "codex-max"
+    if "codex" in model or model.startswith("codex-"):
+        return "codex"
+    if "gpt-5.2" in model:
+        return "gpt-5.2"
+    return "gpt-5.1"
+
+
+def _get_latest_release_tag(client: httpx.Client) -> str:
+    """Get latest release tag from GitHub."""
+    try:
+        response = client.get(GITHUB_API_RELEASES)
+        if response.status_code == 200:
+            data: dict[str, Any] = response.json()
+            tag_name: Any = data.get("tag_name")
+            if isinstance(tag_name, str):
+                return tag_name
+    except httpx.HTTPError:
+        pass
+
+    # Fallback: follow redirect from releases/latest
+    response = client.get(GITHUB_HTML_RELEASES, follow_redirects=True)
+    if response.status_code == 200:
+        final_url = str(response.url)
+        if "/tag/" in final_url:
+            parts = final_url.split("/tag/")
+            if len(parts) > 1 and "/" not in parts[-1]:
+                return parts[-1]
+
+    raise RuntimeError("Failed to determine latest release tag from GitHub")
+
+
+def _load_cache_metadata(meta_file: Path) -> CacheMetadata | None:
+    if not meta_file.exists():
+        return None
+    try:
+        data = json.loads(meta_file.read_text())
+        return CacheMetadata.from_dict(data)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+def _save_cache_metadata(meta_file: Path, metadata: CacheMetadata) -> None:
+    meta_file.parent.mkdir(parents=True, exist_ok=True)
+    meta_file.write_text(json.dumps(metadata.to_dict(), indent=2))
+
+
+def get_codex_instructions(model: str = "gpt-5.1-codex", force_refresh: bool = False) -> str:
+    """Get Codex instructions for the given model.
+
+    Args:
+        model: Model name to get instructions for.
+        force_refresh: If True, bypass cache TTL and fetch fresh instructions.
+
+    Returns:
+        The Codex system prompt instructions.
+    """
+    model_family = get_model_family(model)
+    prompt_file = PROMPT_FILES[model_family]
+    cache_file = CACHE_DIR / CACHE_FILES[model_family]
+    meta_file = CACHE_DIR / f"{CACHE_FILES[model_family].replace('.md', '-meta.json')}"
+
+    # Check cache unless force refresh
+    if not force_refresh:
+        metadata = _load_cache_metadata(meta_file)
+        if metadata and cache_file.exists():
+            age = int(time.time()) - metadata.last_checked
+            if age < CACHE_TTL_SECONDS:
+                log_debug(f"Using cached {model_family} instructions (age: {age}s)", debug_type=DebugType.GENERAL)
+                return cache_file.read_text()
+
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            latest_tag = _get_latest_release_tag(client)
+            instructions_url = f"{GITHUB_RAW_BASE}/{latest_tag}/codex-rs/core/{prompt_file}"
+
+            # Load existing metadata for conditional request
+            metadata = _load_cache_metadata(meta_file)
+            headers: dict[str, str] = {}
+
+            # Only use ETag if tag matches (different release = different content)
+            if metadata and metadata.tag == latest_tag and metadata.etag:
+                headers["If-None-Match"] = metadata.etag
+
+            response = client.get(instructions_url, headers=headers)
+
+            if response.status_code == 304 and cache_file.exists():
+                # Not modified, update last_checked and return cached
+                if metadata:
+                    metadata.last_checked = int(time.time())
+                    _save_cache_metadata(meta_file, metadata)
+                log_debug(f"Codex {model_family} instructions not modified", debug_type=DebugType.GENERAL)
+                return cache_file.read_text()
+
+            if response.status_code == 200:
+                instructions = response.text
+                new_etag = response.headers.get("etag")
+
+                # Save to cache
+                cache_file.parent.mkdir(parents=True, exist_ok=True)
+                cache_file.write_text(instructions)
+                _save_cache_metadata(
+                    meta_file,
+                    CacheMetadata(
+                        etag=new_etag,
+                        tag=latest_tag,
+                        last_checked=int(time.time()),
+                        url=instructions_url,
+                    ),
+                )
+
+                log_debug(f"Updated {model_family} instructions from GitHub", debug_type=DebugType.GENERAL)
+                return instructions
+
+            raise RuntimeError(f"HTTP {response.status_code}")
+
+    except Exception as e:
+        log_debug(f"Failed to fetch {model_family} instructions: {e}", debug_type=DebugType.GENERAL)
+
+        # Fallback to cached version
+        if cache_file.exists():
+            log_debug(f"Using cached {model_family} instructions (fallback)", debug_type=DebugType.GENERAL)
+            return cache_file.read_text()
+
+        # Last resort: use bundled prompt
+        bundled_path = _get_bundled_prompt_path(model_family)
+        if bundled_path:
+            log_debug(f"Using bundled {model_family} instructions (fallback)", debug_type=DebugType.GENERAL)
+            return _load_bundled_prompt(bundled_path)
+
+        raise RuntimeError(f"No Codex instructions available for {model_family}") from e
+
+
+def _get_bundled_prompt_path(model_family: ModelFamily) -> str | None:
+    """Get bundled prompt path for model family."""
+    if model_family == "gpt-5.2-codex":
+        return "prompts/prompt-codex-gpt-5-2-codex.md"
+    if model_family == "gpt-5.2":
+        return "prompts/prompt-codex-gpt-5-2.md"
+    if model_family in ("codex", "codex-max", "gpt-5.1"):
+        return "prompts/prompt-codex.md"
+    return None
+
+
+def invalidate_cache(model: str | None = None) -> None:
+    """Invalidate cached instructions to force refresh on next access.
+
+    Args:
+        model: If provided, only invalidate cache for this model's family.
+               If None, invalidate all cached instructions.
+    """
+    if model:
+        model_family = get_model_family(model)
+        meta_file = CACHE_DIR / f"{CACHE_FILES[model_family].replace('.md', '-meta.json')}"
+        if meta_file.exists():
+            meta_file.unlink()
+    else:
+        if CACHE_DIR.exists():
+            for meta_file in CACHE_DIR.glob("*-meta.json"):
+                meta_file.unlink()

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

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.