klaude-code 2.2.0__py3-none-any.whl → 2.3.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/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,
     )

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/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/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,24 @@ 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 +127,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/input.py

@@ -2,7 +2,7 @@
 # pyright: reportArgumentType=false
 # pyright: reportAssignmentType=false
 
-from typing import Any
+from typing import Any, cast
 
 from openai.types import responses
 
@@ -23,15 +23,25 @@ def _build_user_content_parts(
     parts: list[responses.ResponseInputContentParam] = []
     for part in user.parts:
         if isinstance(part, message.TextPart):
-            parts.append({"type": "input_text", "text": part.text})
+            parts.append(cast(responses.ResponseInputContentParam, {"type": "input_text", "text": part.text}))
         elif isinstance(part, message.ImageURLPart):
-            parts.append({"type": "input_image", "detail": "auto", "image_url": part.url})
+            parts.append(
+                cast(
+                    responses.ResponseInputContentParam,
+                    {"type": "input_image", "detail": "auto", "image_url": part.url},
+                )
+            )
     if attachment.text:
-        parts.append({"type": "input_text", "text": attachment.text})
+        parts.append(cast(responses.ResponseInputContentParam, {"type": "input_text", "text": attachment.text}))
     for image in attachment.images:
-        parts.append({"type": "input_image", "detail": "auto", "image_url": image.url})
+        parts.append(
+            cast(
+                responses.ResponseInputContentParam,
+                {"type": "input_image", "detail": "auto", "image_url": image.url},
+            )
+        )
     if not parts:
-        parts.append({"type": "input_text", "text": ""})
+        parts.append(cast(responses.ResponseInputContentParam, {"type": "input_text", "text": ""}))
     return parts
 
 
@@ -45,17 +55,22 @@ def _build_tool_result_item(
         attachment.text,
     )
     if text_output:
-        content_parts.append({"type": "input_text", "text": 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
     for image in images:
-        content_parts.append({"type": "input_image", "detail": "auto", "image_url": image.url})
+        content_parts.append(
+            cast(
+                responses.ResponseInputContentParam,
+                {"type": "input_image", "detail": "auto", "image_url": image.url},
+            )
+        )
 
     item: dict[str, Any] = {
         "type": "function_call_output",
         "call_id": tool.call_id,
         "output": content_parts,
     }
-    return item
+    return cast(responses.ResponseInputItemParam, item)
 
 
 def convert_history_to_input(
@@ -73,25 +88,30 @@ def convert_history_to_input(
                 system_text = "\n".join(part.text for part in msg.parts)
                 if system_text:
                     items.append(
-                        {
-                            "type": "message",
-                            "role": "system",
-                            "content": [
-                                {
-                                    "type": "input_text",
-                                    "text": system_text,
-                                }
-                            ],
-                        }
+                        cast(
+                            responses.ResponseInputItemParam,
+                            {
+                                "type": "message",
+                                "role": "system",
+                                "content": [
+                                    cast(
+                                        responses.ResponseInputContentParam,
+                                        {"type": "input_text", "text": system_text},
+                                    )
+                                ],
+                            },
+                        )
                     )
             case message.UserMessage():
                 items.append(
-                    {
-                        "type": "message",
-                        "role": "user",
-                        "id": msg.id,
-                        "content": _build_user_content_parts(msg, attachment),
-                    }
+                    cast(
+                        responses.ResponseInputItemParam,
+                        {
+                            "type": "message",
+                            "role": "user",
+                            "content": _build_user_content_parts(msg, attachment),
+                        },
+                    )
                 )
             case message.ToolResultMessage():
                 items.append(_build_tool_result_item(msg, attachment))
@@ -103,17 +123,19 @@ def convert_history_to_input(
                 native_thinking_ids = {id(part) for part in native_thinking_parts}
                 degraded_thinking_texts.extend(degraded_for_message)
 
-                def flush_text(*, _message_id: str = msg.id) -> None:
+                def flush_text() -> None:
                     nonlocal assistant_text_parts
                     if not assistant_text_parts:
                         return
                     items.append(
-                        {
-                            "type": "message",
-                            "role": "assistant",
-                            "id": _message_id,
-                            "content": assistant_text_parts,
-                        }
+                        cast(
+                            responses.ResponseInputItemParam,
+                            {
+                                "type": "message",
+                                "role": "assistant",
+                                "content": assistant_text_parts,
+                            },
+                        )
                     )
                     assistant_text_parts = []
 
@@ -140,17 +162,25 @@ def convert_history_to_input(
 
                     emit_reasoning()
                     if isinstance(part, message.TextPart):
-                        assistant_text_parts.append({"type": "output_text", "text": part.text})
+                        assistant_text_parts.append(
+                            cast(
+                                responses.ResponseInputContentParam,
+                                {"type": "input_text", "text": part.text},
+                            )
+                        )
                     elif isinstance(part, message.ToolCallPart):
                         flush_text()
                         items.append(
-                            {
-                                "type": "function_call",
-                                "name": part.tool_name,
-                                "arguments": part.arguments_json,
-                                "call_id": part.call_id,
-                                "id": part.id,
-                            }
+                            cast(
+                                responses.ResponseInputItemParam,
+                                {
+                                    "type": "function_call",
+                                    "name": part.tool_name,
+                                    "arguments": part.arguments_json,
+                                    "call_id": part.call_id,
+                                    "id": part.id,
+                                },
+                            )
                         )
 
                 emit_reasoning()
@@ -159,16 +189,22 @@ def convert_history_to_input(
                 continue
 
     if degraded_thinking_texts:
-        degraded_item: responses.ResponseInputItemParam = {
-            "type": "message",
-            "role": "assistant",
-            "content": [
-                {
-                    "type": "output_text",
-                    "text": "<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>",
-                }
-            ],
-        }
+        degraded_item = cast(
+            responses.ResponseInputItemParam,
+            {
+                "type": "message",
+                "role": "assistant",
+                "content": [
+                    cast(
+                        responses.ResponseInputContentParam,
+                        {
+                            "type": "input_text",
+                            "text": "<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>",
+                        },
+                    )
+                ],
+            },
+        )
         items.insert(0, degraded_item)
 
     return items
@@ -184,7 +220,7 @@ def convert_reasoning_inputs(text_content: str | None, signature: str | None) ->
     ]
     if signature:
         result["encrypted_content"] = signature
-    return result
+    return cast(responses.ResponseInputItemParam, result)
 
 
 def convert_tool_schema(
@@ -193,11 +229,14 @@ def convert_tool_schema(
     if tools is None:
         return []
     return [
-        {
-            "type": "function",
-            "name": tool.name,
-            "description": tool.description,
-            "parameters": tool.parameters,
-        }
+        cast(
+            responses.ToolParam,
+            {
+                "type": "function",
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+            },
+        )
         for tool in tools
     ]