klaude-code 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

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,
     )
@@ -242,7 +242,7 @@ async def parse_google_stream(
 
             if call_id not in started_tool_items:
                 started_tool_items.add(call_id)
-                yield message.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
+                yield message.ToolCallStartDelta(response_id=response_id, call_id=call_id, name=name)
 
             args_obj = getattr(function_call, "args", None)
             if args_obj is not None:

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/openai_compatible/stream.py

@@ -303,7 +303,7 @@ async def parse_chat_completions_stream(
                 for tc in tool_calls:
                     if tc.index not in state.emitted_tool_start_indices and tc.function and tc.function.name:
                         state.emitted_tool_start_indices.add(tc.index)
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=state.response_id,
                             call_id=tc.id or "",
                             name=tc.function.name,

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

@@ -145,7 +145,7 @@ async def parse_responses_stream(
                 case responses.ResponseOutputItemAddedEvent() as event:
                     if isinstance(event.item, responses.ResponseFunctionToolCall):
                         metadata_tracker.record_token()
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=response_id,
                             call_id=event.item.call_id,
                             name=event.item.name,

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
     ]

klaude_code/protocol/commands.py

@@ -15,8 +15,8 @@ class CommandInfo:
 class CommandName(str, Enum):
     INIT = "init"
     DEBUG = "debug"
-    HELP = "help"
     MODEL = "model"
+    SUB_AGENT_MODEL = "sub-agent-model"
     COMPACT = "compact"
     REFRESH_TERMINAL = "refresh-terminal"
     CLEAR = "clear"
@@ -24,7 +24,6 @@ class CommandName(str, Enum):
     EXPORT = "export"
     EXPORT_ONLINE = "export-online"
     STATUS = "status"
-    RELEASE_NOTES = "release-notes"
     THINKING = "thinking"
     FORK_SESSION = "fork-session"
     RESUME = "resume"

klaude_code/protocol/events/system.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pydantic import Field
+
 from klaude_code.protocol import llm_param
 from klaude_code.protocol.events.chat import DeveloperMessageEvent, UserMessageEvent
 from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnStartEvent
@@ -14,6 +16,8 @@ class WelcomeEvent(Event):
     work_dir: str
     llm_config: llm_param.LLMConfigParameter
     show_klaude_code_info: bool = True
+    show_sub_agent_models: bool = True
+    sub_agent_models: dict[str, llm_param.LLMConfigParameter] = Field(default_factory=dict)
 
 
 class ErrorEvent(Event):

klaude_code/protocol/message.py

@@ -25,7 +25,7 @@ from klaude_code.protocol.model import (
 # Stream items
 
 
-class ToolCallStartItem(BaseModel):
+class ToolCallStartDelta(BaseModel):
     """Transient streaming signal when LLM starts a tool call.
 
     This is NOT persisted to conversation history. Used only for
@@ -175,7 +175,7 @@ Message = SystemMessage | DeveloperMessage | UserMessage | AssistantMessage | To
 
 HistoryEvent = Message | StreamErrorItem | TaskMetadataItem
 
-StreamItem = AssistantTextDelta | AssistantImageDelta | ThinkingTextDelta | ToolCallStartItem
+StreamItem = AssistantTextDelta | AssistantImageDelta | ThinkingTextDelta | ToolCallStartDelta
 
 LLMStreamItem = HistoryEvent | StreamItem
 

klaude_code/protocol/op.py

@@ -25,6 +25,7 @@ class OperationType(Enum):
 
     RUN_AGENT = "run_agent"
     CHANGE_MODEL = "change_model"
+    CHANGE_SUB_AGENT_MODEL = "change_sub_agent_model"
     CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
     RESUME_SESSION = "resume_session"
@@ -97,6 +98,22 @@ class ChangeThinkingOperation(Operation):
         await handler.handle_change_thinking(self)
 
 
+class ChangeSubAgentModelOperation(Operation):
+    """Operation for changing the model used by a specific sub-agent."""
+
+    type: OperationType = OperationType.CHANGE_SUB_AGENT_MODEL
+    session_id: str
+    sub_agent_type: str
+    # When None, clear explicit override and fall back to the sub-agent's default
+    # behavior (usually inherit from main agent; some sub-agents auto-resolve a
+    # suitable model, e.g. ImageGen).
+    model_name: str | None
+    save_as_default: bool = False
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_sub_agent_model(self)
+
+
 class ClearSessionOperation(Operation):
     """Operation for clearing the active session and starting a new one."""
 

klaude_code/protocol/op_handler.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Protocol
 if TYPE_CHECKING:
     from klaude_code.protocol.op import (
         ChangeModelOperation,
+        ChangeSubAgentModelOperation,
         ChangeThinkingOperation,
         ClearSessionOperation,
         ExportSessionOperation,
@@ -36,6 +37,10 @@ class OperationHandler(Protocol):
         """Handle a change thinking operation."""
         ...
 
+    async def handle_change_sub_agent_model(self, operation: ChangeSubAgentModelOperation) -> None:
+        """Handle a change sub-agent model operation."""
+        ...
+
     async def handle_clear_session(self, operation: ClearSessionOperation) -> None:
         """Handle a clear session operation."""
         ...

klaude_code/protocol/sub_agent/AGENTS.md

@@ -0,0 +1,28 @@
+# Sub-Agent Protocol
+
+Sub-agents are specialized agents invoked by the main agent as tools. This module defines profiles and registration.
+
+## Key Constraint
+
+The `protocol` layer cannot import from `config` or `core` (enforced by import-linter). Availability checks are delegated to upper layers via string constants.
+
+## Core Files
+
+- `__init__.py` - `SubAgentProfile` dataclass and registration. Defines `AVAILABILITY_*` constants.
+- `image_gen.py`, `task.py`, `explore.py`, `web.py` - Individual sub-agent definitions.
+
+## Availability Requirement Flow
+
+Some sub-agents require specific model capabilities (e.g., ImageGen needs an image model). The flow:
+
+1. `SubAgentProfile.availability_requirement` stores a constant (e.g., `AVAILABILITY_IMAGE_MODEL`)
+2. `config/sub_agent_model_helper.py` checks if the requirement is met based on `config/config.py`
+3. `config/sub_agent_model_helper.py` resolves the default model when unset (e.g., first available image model)
+4. Core builders/UI call into the helper to avoid dealing with requirement constants directly
+
+## Model Selection
+
+For sub-agents with `availability_requirement`, priority is:
+1. Explicit config in `sub_agent_models`
+2. Auto-resolve via requirement
+3. If neither found, sub-agent is unavailable (no fallback to main agent model)