klaude-code 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

klaude_code/llm/anthropic/input.py

@@ -8,10 +8,13 @@ import json
 from typing import Literal, cast
 
 from anthropic.types.beta.beta_base64_image_source_param import BetaBase64ImageSourceParam
+from anthropic.types.beta.beta_content_block_param import BetaContentBlockParam
 from anthropic.types.beta.beta_image_block_param import BetaImageBlockParam
 from anthropic.types.beta.beta_message_param import BetaMessageParam
 from anthropic.types.beta.beta_text_block_param import BetaTextBlockParam
 from anthropic.types.beta.beta_tool_param import BetaToolParam
+from anthropic.types.beta.beta_tool_result_block_param import BetaToolResultBlockParam
+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
@@ -60,29 +63,29 @@ def _user_message_to_message(
     blocks: list[BetaTextBlockParam | BetaImageBlockParam] = []
     for part in msg.parts:
         if isinstance(part, message.TextPart):
-            blocks.append({"type": "text", "text": part.text})
+            blocks.append(cast(BetaTextBlockParam, {"type": "text", "text": part.text}))
         elif isinstance(part, message.ImageURLPart):
             blocks.append(_image_part_to_block(part))
     if attachment.text:
-        blocks.append({"type": "text", "text": attachment.text})
+        blocks.append(cast(BetaTextBlockParam, {"type": "text", "text": attachment.text}))
     for image in attachment.images:
         blocks.append(_image_part_to_block(image))
     if not blocks:
-        blocks.append({"type": "text", "text": ""})
+        blocks.append(cast(BetaTextBlockParam, {"type": "text", "text": ""}))
     return {"role": "user", "content": blocks}
 
 
 def _tool_message_to_block(
     msg: message.ToolResultMessage,
     attachment: DeveloperAttachment,
-) -> dict[str, object]:
+) -> BetaToolResultBlockParam:
     """Convert a single tool result message to a tool_result block."""
     tool_content: list[BetaTextBlockParam | BetaImageBlockParam] = []
     merged_text = merge_reminder_text(
         msg.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
         attachment.text,
     )
-    tool_content.append({"type": "text", "text": merged_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)]:
         tool_content.append(_image_part_to_block(image))
     for image in attachment.images:
@@ -95,7 +98,7 @@ def _tool_message_to_block(
     }
 
 
-def _tool_blocks_to_message(blocks: list[dict[str, object]]) -> BetaMessageParam:
+def _tool_blocks_to_message(blocks: list[BetaToolResultBlockParam]) -> BetaMessageParam:
     """Convert one or more tool_result blocks to a single user message."""
     return {
         "role": "user",
@@ -104,7 +107,7 @@ def _tool_blocks_to_message(blocks: list[dict[str, object]]) -> BetaMessageParam
 
 
 def _assistant_message_to_message(msg: message.AssistantMessage, model_name: str | None) -> BetaMessageParam:
-    content: list[dict[str, object]] = []
+    content: list[BetaContentBlockParam] = []
     current_thinking_content: str | None = None
     native_thinking_parts, degraded_thinking_texts = split_thinking_parts(msg, model_name)
     native_thinking_ids = {id(part) for part in native_thinking_parts}
@@ -113,7 +116,7 @@ def _assistant_message_to_message(msg: message.AssistantMessage, model_name: str
         nonlocal current_thinking_content
         if current_thinking_content is None:
             return
-        content.append({"type": "thinking", "thinking": current_thinking_content})
+        degraded_thinking_texts.append(current_thinking_content)
         current_thinking_content = None
 
     for part in msg.parts:
@@ -127,33 +130,47 @@ def _assistant_message_to_message(msg: message.AssistantMessage, model_name: str
                 continue
             if part.signature:
                 content.append(
-                    {
-                        "type": "thinking",
-                        "thinking": current_thinking_content or "",
-                        "signature": part.signature,
-                    }
+                    cast(
+                        BetaContentBlockParam,
+                        {
+                            "type": "thinking",
+                            "thinking": current_thinking_content or "",
+                            "signature": part.signature,
+                        },
+                    )
                 )
                 current_thinking_content = None
             continue
 
         _flush_thinking()
         if isinstance(part, message.TextPart):
-            content.append({"type": "text", "text": part.text})
+            content.append(cast(BetaTextBlockParam, {"type": "text", "text": part.text}))
         elif isinstance(part, message.ToolCallPart):
+            tool_input: dict[str, object] = {}
+            if part.arguments_json:
+                try:
+                    parsed = json.loads(part.arguments_json)
+                except json.JSONDecodeError:
+                    parsed = {"_raw": part.arguments_json}
+                tool_input = cast(dict[str, object], parsed) if isinstance(parsed, dict) else {"_value": parsed}
+
             content.append(
-                {
-                    "type": "tool_use",
-                    "id": part.call_id,
-                    "name": part.tool_name,
-                    "input": json.loads(part.arguments_json) if part.arguments_json else None,
-                }
+                cast(
+                    BetaToolUseBlockParam,
+                    {
+                        "type": "tool_use",
+                        "id": part.call_id,
+                        "name": part.tool_name,
+                        "input": tool_input,
+                    },
+                )
             )
 
     _flush_thinking()
 
     if degraded_thinking_texts:
         degraded_text = "<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>"
-        content.insert(0, {"type": "text", "text": degraded_text})
+        content.insert(0, cast(BetaTextBlockParam, {"type": "text", "text": degraded_text}))
 
     return {"role": "assistant", "content": content}
 
@@ -174,7 +191,7 @@ def convert_history_to_input(
 ) -> list[BetaMessageParam]:
     """Convert a list of messages to beta message params."""
     messages: list[BetaMessageParam] = []
-    pending_tool_blocks: list[dict[str, object]] = []
+    pending_tool_blocks: list[BetaToolResultBlockParam] = []
 
     def flush_tool_blocks() -> None:
         nonlocal pending_tool_blocks
@@ -213,7 +230,12 @@ def convert_system_to_input(
             parts.append("\n".join(part.text for part in msg.parts))
     if not parts:
         return []
-    return [{"type": "text", "text": "\n".join(parts), "cache_control": {"type": "ephemeral"}}]
+    block: BetaTextBlockParam = {
+        "type": "text",
+        "text": "\n".join(parts),
+        "cache_control": {"type": "ephemeral"},
+    }
+    return [block]
 
 
 def convert_tool_schema(
@@ -222,11 +244,14 @@ def convert_tool_schema(
     if tools is None:
         return []
     return [
-        {
-            "input_schema": tool.parameters,
-            "type": "custom",
-            "name": tool.name,
-            "description": tool.description,
-        }
+        cast(
+            BetaToolParam,
+            {
+                "input_schema": tool.parameters,
+                "type": "custom",
+                "name": tool.name,
+                "description": tool.description,
+            },
+        )
         for tool in tools
     ]

klaude_code/llm/client.py

@@ -25,7 +25,7 @@ class LLMClientABC(ABC):
 
     @property
     def model_name(self) -> str:
-        return self._config.model or ""
+        return self._config.model_id or ""
 
     @property
     def protocol(self) -> llm_param.LLMClientProtocol:

klaude_code/llm/codex/client.py

@@ -31,13 +31,13 @@ from klaude_code.protocol import llm_param, message
 
 def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
     """Build Codex API request parameters."""
-    inputs = convert_history_to_input(param.input, param.model)
+    inputs = convert_history_to_input(param.input, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     session_id = param.session_id or ""
 
     payload: ResponseCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "include": [

klaude_code/llm/google/client.py

@@ -54,7 +54,7 @@ def _build_config(param: llm_param.LLMCallParameter) -> GenerateContentConfig:
         system_instruction=param.system,
         temperature=param.temperature,
         max_output_tokens=param.max_tokens,
-        tools=tool_list or None,
+        tools=cast(Any, tool_list) if tool_list else None,
         tool_config=tool_config,
         thinking_config=thinking_config,
     )
@@ -163,7 +163,7 @@ async def parse_google_stream(
             assistant_parts.append(
                 message.ThinkingTextPart(
                     text="".join(accumulated_thoughts),
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                 )
             )
             accumulated_thoughts.clear()
@@ -171,7 +171,7 @@ async def parse_google_stream(
             assistant_parts.append(
                 message.ThinkingSignaturePart(
                     signature=thought_signature,
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                     format="google_thought_signature",
                 )
             )
@@ -301,7 +301,7 @@ async def parse_google_stream(
     usage = _usage_from_metadata(last_usage_metadata, context_limit=param.context_limit, max_tokens=param.max_tokens)
     if usage is not None:
         metadata_tracker.set_usage(usage)
-    metadata_tracker.set_model_name(str(param.model))
+    metadata_tracker.set_model_name(str(param.model_id))
     metadata_tracker.set_response_id(response_id)
     metadata = metadata_tracker.finalize()
     yield message.AssistantMessage(
@@ -336,13 +336,13 @@ class GoogleClient(LLMClientABC):
         param = apply_config_defaults(param, self.get_llm_config())
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        contents = convert_history_to_contents(param.input, model_name=str(param.model))
+        contents = convert_history_to_contents(param.input, model_name=str(param.model_id))
         config = _build_config(param)
 
         log_debug(
             json.dumps(
                 {
-                    "model": str(param.model),
+                    "model": str(param.model_id),
                     "contents": [c.model_dump(exclude_none=True) for c in contents],
                     "config": config.model_dump(exclude_none=True),
                 },
@@ -354,7 +354,7 @@ class GoogleClient(LLMClientABC):
 
         try:
             stream = await self.client.aio.models.generate_content_stream(
-                model=str(param.model),
+                model=str(param.model_id),
                 contents=cast(Any, contents),
                 config=config,
             )

klaude_code/llm/google/input.py

@@ -4,6 +4,8 @@
 # pyright: reportAttributeAccessIssue=false
 
 import json
+from base64 import b64decode
+from binascii import Error as BinasciiError
 from typing import Any
 
 from google.genai import types
@@ -32,6 +34,14 @@ def _image_part_to_part(image: message.ImageURLPart) -> types.Part:
     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
+    if url.startswith("data:"):
+        media_type, _, decoded = parse_data_url(url)
+        return types.FunctionResponsePart.from_bytes(data=decoded, mime_type=media_type)
+    return types.FunctionResponsePart.from_uri(file_uri=url)
+
+
 def _user_message_to_content(msg: message.UserMessage, attachment: DeveloperAttachment) -> types.Content:
     parts: list[types.Part] = []
     for part in msg.parts:
@@ -65,9 +75,12 @@ def _tool_messages_to_contents(
 
         images = [part for part in msg.parts if isinstance(part, message.ImageURLPart)] + attachment.images
         image_parts: list[types.Part] = []
+        function_response_parts: list[types.FunctionResponsePart] = []
+
         for image in images:
             try:
                 image_parts.append(_image_part_to_part(image))
+                function_response_parts.append(_image_part_to_function_response_part(image))
             except ValueError:
                 continue
 
@@ -79,7 +92,7 @@ def _tool_messages_to_contents(
             id=msg.call_id,
             name=msg.tool_name,
             response=response_payload,
-            parts=image_parts if (has_images and supports_multimodal_function_response) else None,
+            parts=function_response_parts if (has_images and supports_multimodal_function_response) else None,
         )
         response_parts.append(types.Part(function_response=function_response))
 
@@ -106,11 +119,19 @@ def _assistant_message_to_content(msg: message.AssistantMessage, model_name: str
         nonlocal pending_thought_text, pending_thought_signature
         if pending_thought_text is None and pending_thought_signature is None:
             return
+
+        signature_bytes: bytes | None = None
+        if pending_thought_signature:
+            try:
+                signature_bytes = b64decode(pending_thought_signature)
+            except (BinasciiError, ValueError):
+                signature_bytes = None
+
         parts.append(
             types.Part(
                 text=pending_thought_text or "",
                 thought=True,
-                thought_signature=pending_thought_signature,
+                thought_signature=signature_bytes,
             )
         )
         pending_thought_text = None

klaude_code/llm/input_common.py

@@ -165,8 +165,8 @@ def split_thinking_parts(
 
 def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter") -> "LLMCallParameter":
     """Apply config defaults to LLM call parameters."""
-    if param.model is None:
-        param.model = config.model
+    if param.model_id is None:
+        param.model_id = config.model_id
     if param.temperature is None:
         param.temperature = config.temperature
     if param.max_tokens is None:

klaude_code/llm/openai_compatible/client.py

@@ -19,7 +19,7 @@ from klaude_code.protocol import llm_param, message
 
 def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:
     """Build OpenAI API request parameters."""
-    messages = convert_history_to_input(param.input, param.system, param.model)
+    messages = convert_history_to_input(param.input, param.system, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     extra_body: dict[str, object] = {}
@@ -31,7 +31,7 @@ def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreatePa
         }
 
     payload: CompletionCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "stream": True,
@@ -108,7 +108,7 @@ class OpenAICompatibleClient(LLMClientABC):
             return
 
         reasoning_handler = DefaultReasoningHandler(
-            param_model=str(param.model),
+            param_model=str(param.model_id),
             response_id=None,
         )
 

klaude_code/llm/openai_compatible/input.py

@@ -3,6 +3,8 @@
 # pyright: reportUnknownMemberType=false
 # pyright: reportAttributeAccessIssue=false
 
+from typing import cast
+
 from openai.types import chat
 from openai.types.chat import ChatCompletionContentPartParam
 
@@ -25,14 +27,16 @@ def _assistant_message_to_openai(msg: message.AssistantMessage) -> chat.ChatComp
         assistant_message["content"] = text_content
 
     assistant_message.update(build_assistant_common_fields(msg, image_to_data_url=assistant_image_to_data_url))
-    return assistant_message
+    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 [{"type": "image_url", "image_url": {"url": image.url}} for image in images]
+    return [
+        cast(ChatCompletionContentPartParam, {"type": "image_url", "image_url": {"url": image.url}}) for image in images
+    ]
 
 
 def convert_history_to_input(
@@ -42,19 +46,21 @@ def convert_history_to_input(
 ) -> list[chat.ChatCompletionMessageParam]:
     """Convert a list of messages to chat completion params."""
     del model_name
-    messages: list[chat.ChatCompletionMessageParam] = [{"role": "system", "content": system}] if system else []
+    messages: list[chat.ChatCompletionMessageParam] = (
+        [cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system})] if system else []
+    )
 
     for msg, attachment in attach_developer_messages(history):
         match msg:
             case message.SystemMessage():
                 system_text = "\n".join(part.text for part in msg.parts)
                 if system_text:
-                    messages.append({"role": "system", "content": system_text})
+                    messages.append(cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system_text}))
             case message.UserMessage():
                 parts = build_chat_content_parts(msg, attachment)
-                messages.append({"role": "user", "content": parts})
+                messages.append(cast(chat.ChatCompletionMessageParam, {"role": "user", "content": parts}))
             case message.ToolResultMessage():
-                messages.append(build_tool_message(msg, attachment))
+                messages.append(cast(chat.ChatCompletionMessageParam, build_tool_message(msg, attachment)))
             case message.AssistantMessage():
                 messages.append(_assistant_message_to_openai(msg))
             case _:
@@ -69,13 +75,16 @@ def convert_tool_schema(
     if tools is None:
         return []
     return [
-        {
-            "type": "function",
-            "function": {
-                "name": tool.name,
-                "description": tool.description,
-                "parameters": tool.parameters,
+        cast(
+            chat.ChatCompletionToolParam,
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                },
             },
-        }
+        )
         for tool in tools
     ]

klaude_code/llm/openai_compatible/stream.py

@@ -179,7 +179,7 @@ async def parse_chat_completions_stream(
     """
 
     state = StreamStateManager(
-        param_model=str(param.model),
+        param_model=str(param.model_id),
         reasoning_flusher=reasoning_handler.flush,
     )
 

klaude_code/llm/openrouter/client.py

@@ -30,7 +30,7 @@ def build_payload(
     param: llm_param.LLMCallParameter,
 ) -> tuple[CompletionCreateParamsStreaming, dict[str, object], dict[str, str]]:
     """Build OpenRouter API request parameters."""
-    messages = convert_history_to_input(param.input, param.system, param.model)
+    messages = convert_history_to_input(param.input, param.system, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     extra_body: dict[str, object] = {
@@ -66,13 +66,13 @@ def build_payload(
     if param.provider_routing:
         extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
 
-    if is_claude_model(param.model):
+    if is_claude_model(param.model_id):
         extra_headers["x-anthropic-beta"] = (
             f"{ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING},{ANTHROPIC_BETA_INTERLEAVED_THINKING}"
         )
 
     payload: CompletionCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "stream": True,
@@ -133,7 +133,7 @@ class OpenRouterClient(LLMClientABC):
             return
 
         reasoning_handler = ReasoningStreamHandler(
-            param_model=str(param.model),
+            param_model=str(param.model_id),
             response_id=None,
         )
 

klaude_code/llm/openrouter/input.py

@@ -6,6 +6,8 @@
 # pyright: reportUnnecessaryIsInstance=false
 # pyright: reportGeneralTypeIssues=false
 
+from typing import cast
+
 from openai.types import chat
 
 from klaude_code.llm.image import assistant_image_to_data_url
@@ -71,7 +73,7 @@ def _assistant_message_to_openrouter(
     if content_parts:
         assistant_message["content"] = "\n".join(content_parts)
 
-    return assistant_message
+    return cast(chat.ChatCompletionMessageParam, assistant_message)
 
 
 def _add_cache_control(messages: list[chat.ChatCompletionMessageParam], use_cache_control: bool) -> None:
@@ -98,19 +100,22 @@ def convert_history_to_input(
 
     messages: list[chat.ChatCompletionMessageParam] = (
         [
-            {
-                "role": "system",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": system,
-                        "cache_control": {"type": "ephemeral"},
-                    }
-                ],
-            }
+            cast(
+                chat.ChatCompletionMessageParam,
+                {
+                    "role": "system",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": system,
+                            "cache_control": {"type": "ephemeral"},
+                        }
+                    ],
+                },
+            )
         ]
         if system and use_cache_control
-        else ([{"role": "system", "content": system}] if system else [])
+        else ([cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system})] if system else [])
     )
 
     for msg, attachment in attach_developer_messages(history):
@@ -120,24 +125,29 @@ def convert_history_to_input(
                 if system_text:
                     if use_cache_control:
                         messages.append(
-                            {
-                                "role": "system",
-                                "content": [
-                                    {
-                                        "type": "text",
-                                        "text": system_text,
-                                        "cache_control": {"type": "ephemeral"},
-                                    }
-                                ],
-                            }
+                            cast(
+                                chat.ChatCompletionMessageParam,
+                                {
+                                    "role": "system",
+                                    "content": [
+                                        {
+                                            "type": "text",
+                                            "text": system_text,
+                                            "cache_control": {"type": "ephemeral"},
+                                        }
+                                    ],
+                                },
+                            )
                         )
                     else:
-                        messages.append({"role": "system", "content": system_text})
+                        messages.append(
+                            cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system_text})
+                        )
             case message.UserMessage():
                 parts = build_chat_content_parts(msg, attachment)
-                messages.append({"role": "user", "content": parts})
+                messages.append(cast(chat.ChatCompletionMessageParam, {"role": "user", "content": parts}))
             case message.ToolResultMessage():
-                messages.append(build_tool_message(msg, attachment))
+                messages.append(cast(chat.ChatCompletionMessageParam, build_tool_message(msg, attachment)))
             case message.AssistantMessage():
                 messages.append(_assistant_message_to_openrouter(msg, model_name))
             case _:

klaude_code/llm/responses/client.py

@@ -24,11 +24,11 @@ if TYPE_CHECKING:
 
 def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
     """Build OpenAI Responses API request parameters."""
-    inputs = convert_history_to_input(param.input, param.model)
+    inputs = convert_history_to_input(param.input, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     payload: ResponseCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "include": [
@@ -77,7 +77,7 @@ async def parse_responses_stream(
             assistant_parts.append(
                 message.ThinkingTextPart(
                     text="".join(accumulated_thinking),
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                 )
             )
             accumulated_thinking.clear()
@@ -85,7 +85,7 @@ async def parse_responses_stream(
             assistant_parts.append(
                 message.ThinkingSignaturePart(
                     signature=pending_signature,
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                     format="openai_reasoning",
                 )
             )
@@ -197,7 +197,7 @@ async def parse_responses_stream(
                                 max_tokens=param.max_tokens,
                             )
                         )
-                    metadata_tracker.set_model_name(str(param.model))
+                    metadata_tracker.set_model_name(str(param.model_id))
                     metadata_tracker.set_response_id(response_id)
                     stop_reason = map_stop_reason(event.response.status, error_reason)
                     if event.response.status != "completed":