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

klaude_code/llm/{codex → openai_codex}/__init__.py

@@ -1,5 +1,5 @@
 """Codex LLM client using ChatGPT subscription."""
 
-from klaude_code.llm.codex.client import CodexClient
+from klaude_code.llm.openai_codex.client import CodexClient
 
 __all__ = ["CodexClient"]

klaude_code/llm/{codex → openai_codex}/client.py

@@ -20,9 +20,9 @@ from klaude_code.const import (
 )
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_responses.client import ResponsesLLMStream
+from klaude_code.llm.openai_responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.registry import register
-from klaude_code.llm.responses.client import ResponsesLLMStream
-from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.usage import MetadataTracker, error_llm_stream
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param
@@ -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.openai_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/openai_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/openai_compatible/client.py

@@ -39,9 +39,11 @@ def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreatePa
         "max_tokens": param.max_tokens,
         "tools": tools,
         "reasoning_effort": param.thinking.reasoning_effort if param.thinking else None,
-        "verbosity": param.verbosity,
     }
 
+    if param.verbosity:
+        payload["verbosity"] = param.verbosity
+
     return payload, extra_body
 
 

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.
 
@@ -61,9 +76,11 @@ class StreamStateManager:
         """Set the response ID once received from the stream."""
         self.response_id = response_id
 
-    def append_thinking_text(self, text: str) -> None:
+    def append_thinking_text(self, text: str, *, reasoning_field: str | None = None) -> None:
         """Append thinking text, merging with the previous ThinkingTextPart when possible."""
-        append_thinking_text_part(self.assistant_parts, text, model_id=self.param_model)
+        append_thinking_text_part(
+            self.assistant_parts, text, model_id=self.param_model, reasoning_field=reasoning_field
+        )
 
     def append_text(self, text: str) -> None:
         """Append assistant text, merging with the previous TextPart when possible."""
@@ -135,6 +152,7 @@ class ReasoningDeltaResult:
 
     handled: bool
     outputs: list[str | message.Part]
+    reasoning_field: str | None = None  # Original field name: reasoning_content, reasoning, reasoning_text
 
 
 class ReasoningHandlerABC(ABC):
@@ -153,8 +171,11 @@ class ReasoningHandlerABC(ABC):
         """Flush buffered reasoning content (usually at stage transition/finalize)."""
 
 
+REASONING_FIELDS = ("reasoning_content", "reasoning", "reasoning_text")
+
+
 class DefaultReasoningHandler(ReasoningHandlerABC):
-    """Handles OpenAI-compatible reasoning fields (reasoning_content / reasoning)."""
+    """Handles OpenAI-compatible reasoning fields (reasoning_content / reasoning / reasoning_text)."""
 
     def __init__(
         self,
@@ -164,16 +185,20 @@ class DefaultReasoningHandler(ReasoningHandlerABC):
     ) -> None:
         self._param_model = param_model
         self._response_id = response_id
+        self._reasoning_field: str | None = None
 
     def set_response_id(self, response_id: str | None) -> None:
         self._response_id = response_id
 
     def on_delta(self, delta: object) -> ReasoningDeltaResult:
-        reasoning_content = getattr(delta, "reasoning_content", None) or getattr(delta, "reasoning", None) or ""
-        if not reasoning_content:
-            return ReasoningDeltaResult(handled=False, outputs=[])
-        text = str(reasoning_content)
-        return ReasoningDeltaResult(handled=True, outputs=[text])
+        for field_name in REASONING_FIELDS:
+            content = getattr(delta, field_name, None)
+            if content:
+                if self._reasoning_field is None:
+                    self._reasoning_field = field_name
+                text = str(content)
+                return ReasoningDeltaResult(handled=True, outputs=[text], reasoning_field=self._reasoning_field)
+        return ReasoningDeltaResult(handled=False, outputs=[])
 
     def flush(self) -> list[message.Part]:
         return []
@@ -267,7 +292,7 @@ async def parse_chat_completions_stream(
                         if not output:
                             continue
                         metadata_tracker.record_token()
-                        state.append_thinking_text(output)
+                        state.append_thinking_text(output, reasoning_field=reasoning_result.reasoning_field)
                         yield message.ThinkingTextDelta(content=output, response_id=state.response_id)
                     else:
                         state.assistant_parts.append(output)

klaude_code/llm/{responses → openai_responses}/client.py

@@ -11,8 +11,8 @@ from openai.types.responses.response_create_params import ResponseCreateParamsSt
 from klaude_code.const import LLM_HTTP_TIMEOUT_CONNECT, LLM_HTTP_TIMEOUT_READ, LLM_HTTP_TIMEOUT_TOTAL
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.registry import register
-from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.stream_parts import (
     append_text_part,
     append_thinking_text_part,

klaude_code/llm/{responses → openai_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/registry.py

@@ -15,11 +15,11 @@ _REGISTRY: dict[llm_param.LLMClientProtocol, type["LLMClientABC"]] = {}
 _PROTOCOL_MODULES: dict[llm_param.LLMClientProtocol, str] = {
     llm_param.LLMClientProtocol.ANTHROPIC: "klaude_code.llm.anthropic",
     llm_param.LLMClientProtocol.CLAUDE_OAUTH: "klaude_code.llm.claude",
-    llm_param.LLMClientProtocol.BEDROCK: "klaude_code.llm.bedrock",
-    llm_param.LLMClientProtocol.CODEX_OAUTH: "klaude_code.llm.codex",
+    llm_param.LLMClientProtocol.BEDROCK: "klaude_code.llm.bedrock_anthropic",
+    llm_param.LLMClientProtocol.CODEX_OAUTH: "klaude_code.llm.openai_codex",
     llm_param.LLMClientProtocol.OPENAI: "klaude_code.llm.openai_compatible",
     llm_param.LLMClientProtocol.OPENROUTER: "klaude_code.llm.openrouter",
-    llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.responses",
+    llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.openai_responses",
     llm_param.LLMClientProtocol.GOOGLE: "klaude_code.llm.google",
     llm_param.LLMClientProtocol.ANTIGRAVITY: "klaude_code.llm.antigravity",
 }
@@ -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/stream_parts.py

@@ -24,6 +24,7 @@ def append_thinking_text_part(
     text: str,
     *,
     model_id: str,
+    reasoning_field: str | None = None,
     force_new: bool = False,
 ) -> int | None:
     if not text:
@@ -35,10 +36,11 @@ def append_thinking_text_part(
             parts[-1] = message.ThinkingTextPart(
                 text=last.text + text,
                 model_id=model_id,
+                reasoning_field=reasoning_field or last.reasoning_field,
             )
             return len(parts) - 1
 
-    parts.append(message.ThinkingTextPart(text=text, model_id=model_id))
+    parts.append(message.ThinkingTextPart(text=text, model_id=model_id, reasoning_field=reasoning_field))
     return len(parts) - 1
 
 

klaude_code/llm/usage.py

@@ -28,7 +28,7 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     usage.output_cost = (usage.output_tokens / 1_000_000) * cost_config.output
 
     # Cache read cost
-    usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * cost_config.cache_read
+    usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * (cost_config.cache_read or cost_config.input)
 
     # Image generation cost
     usage.image_cost = (usage.image_tokens / 1_000_000) * cost_config.image
@@ -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/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):
@@ -118,7 +119,6 @@ class UsageEvent(ResponseEvent):
 
 class TaskMetadataEvent(Event):
     metadata: model.TaskMetadataItem
-    cancelled: bool = False
 
 
 class ThinkingStartEvent(ResponseEvent):

klaude_code/protocol/message.py

@@ -112,6 +112,7 @@ class ThinkingTextPart(BaseModel):
     id: str | None = None
     text: str
     model_id: str | None = None
+    reasoning_field: str | None = None  # Original field name: reasoning_content, reasoning, reasoning_text
 
 
 class ThinkingSignaturePart(BaseModel):
@@ -213,7 +214,7 @@ class UserInputPayload(BaseModel):
     """
 
     text: str
-    images: list[ImageURLPart] | None = None
+    images: Sequence[ImageURLPart | ImageFilePart] | None = None
 
 
 # Helper functions
@@ -225,7 +226,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))