klaude-code 1.9.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

klaude_code/llm/responses/input.py

@@ -6,29 +6,49 @@ from typing import Any
 
 from openai.types import responses
 
-from klaude_code.protocol import llm_param, model
+from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.input_common import (
+    DeveloperAttachment,
+    attach_developer_messages,
+    merge_reminder_text,
+    split_thinking_parts,
+)
+from klaude_code.protocol import llm_param, message
 
 
 def _build_user_content_parts(
-    user: model.UserMessageItem,
+    user: message.UserMessage,
+    attachment: DeveloperAttachment,
 ) -> list[responses.ResponseInputContentParam]:
     parts: list[responses.ResponseInputContentParam] = []
-    if user.content is not None:
-        parts.append({"type": "input_text", "text": user.content})
-    for image in user.images or []:
-        parts.append({"type": "input_image", "detail": "auto", "image_url": image.image_url.url})
+    for part in user.parts:
+        if isinstance(part, message.TextPart):
+            parts.append({"type": "input_text", "text": part.text})
+        elif isinstance(part, message.ImageURLPart):
+            parts.append({"type": "input_image", "detail": "auto", "image_url": part.url})
+    if attachment.text:
+        parts.append({"type": "input_text", "text": attachment.text})
+    for image in attachment.images:
+        parts.append({"type": "input_image", "detail": "auto", "image_url": image.url})
     if not parts:
         parts.append({"type": "input_text", "text": ""})
     return parts
 
 
-def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInputItemParam:
+def _build_tool_result_item(
+    tool: message.ToolResultMessage,
+    attachment: DeveloperAttachment,
+) -> responses.ResponseInputItemParam:
     content_parts: list[responses.ResponseInputContentParam] = []
-    text_output = tool.output or "<system-reminder>Tool ran without output or errors</system-reminder>"
+    text_output = merge_reminder_text(
+        tool.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
+        attachment.text,
+    )
     if text_output:
         content_parts.append({"type": "input_text", "text": text_output})
-    for image in tool.images or []:
-        content_parts.append({"type": "input_image", "detail": "auto", "image_url": image.image_url.url})
+    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})
 
     item: dict[str, Any] = {
         "type": "function_call_output",
@@ -39,103 +59,105 @@ def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInp
 
 
 def convert_history_to_input(
-    history: list[model.ConversationItem],
+    history: list[message.Message],
     model_name: str | None = None,
 ) -> responses.ResponseInputParam:
-    """
-    Convert a list of conversation items to a list of response input params.
-
-    Args:
-        history: List of conversation items.
-        model_name: Model name. Used to verify that signatures are valid for the same model.
-    """
+    """Convert a list of messages to response input params."""
     items: list[responses.ResponseInputItemParam] = []
 
-    pending_reasoning_text: str | None = None
     degraded_thinking_texts: list[str] = []
 
-    for item in history:
-        match item:
-            case model.ReasoningTextItem() as item:
-                # For now, we only store the text. We wait for the encrypted item to output both.
-                # If no encrypted item follows (e.g. incomplete stream?), this text might be lost
-                # or we can choose to output it if the next item is NOT reasoning?
-                # For now, based on instructions, we pair them.
-                if model_name != item.model:
-                    # Cross-model: collect thinking text for degradation
-                    if item.content:
-                        degraded_thinking_texts.append(item.content)
-                    continue
-                pending_reasoning_text = item.content
-
-            case model.ReasoningEncryptedItem() as item:
-                if item.encrypted_content and len(item.encrypted_content) > 0 and model_name == item.model:
-                    items.append(convert_reasoning_inputs(pending_reasoning_text, item))
-                # Reset pending text after consumption
-                pending_reasoning_text = None
-
-            case model.ToolCallItem() as t:
-                items.append(
-                    {
-                        "type": "function_call",
-                        "name": t.name,
-                        "arguments": t.arguments,
-                        "call_id": t.call_id,
-                        "id": t.id,
-                    }
-                )
-            case model.ToolResultItem() as t:
-                items.append(_build_tool_result_item(t))
-            case model.AssistantMessageItem() as a:
-                items.append(
-                    {
-                        "type": "message",
-                        "role": "assistant",
-                        "id": a.id,
-                        "content": [
-                            {
-                                "type": "output_text",
-                                "text": a.content,
-                            }
-                        ],
-                    }
-                )
-            case model.UserMessageItem() as u:
+    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:
+                    items.append(
+                        {
+                            "type": "message",
+                            "role": "system",
+                            "content": [
+                                {
+                                    "type": "input_text",
+                                    "text": system_text,
+                                }
+                            ],
+                        }
+                    )
+            case message.UserMessage():
                 items.append(
                     {
                         "type": "message",
                         "role": "user",
-                        "id": u.id,
-                        "content": _build_user_content_parts(u),
+                        "id": msg.id,
+                        "content": _build_user_content_parts(msg, attachment),
                     }
                 )
-            case model.DeveloperMessageItem() as d:
-                dev_parts: list[responses.ResponseInputContentParam] = []
-                if d.content is not None:
-                    dev_parts.append({"type": "input_text", "text": d.content})
-                for image in d.images or []:
-                    dev_parts.append(
+            case message.ToolResultMessage():
+                items.append(_build_tool_result_item(msg, attachment))
+            case message.AssistantMessage():
+                assistant_text_parts: list[responses.ResponseInputContentParam] = []
+                pending_thinking_text: str | None = None
+                pending_signature: str | None = None
+                native_thinking_parts, degraded_for_message = split_thinking_parts(msg, model_name)
+                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:
+                    nonlocal assistant_text_parts
+                    if not assistant_text_parts:
+                        return
+                    items.append(
                         {
-                            "type": "input_image",
-                            "detail": "auto",
-                            "image_url": image.image_url.url,
+                            "type": "message",
+                            "role": "assistant",
+                            "id": _message_id,
+                            "content": assistant_text_parts,
                         }
                     )
-                if not dev_parts:
-                    dev_parts.append({"type": "input_text", "text": ""})
-                items.append(
-                    {
-                        "type": "message",
-                        "role": "user",  # GPT-5 series do not support image in "developer" role, so we set it to "user"
-                        "id": d.id,
-                        "content": dev_parts,
-                    }
-                )
+                    assistant_text_parts = []
+
+                def emit_reasoning() -> None:
+                    nonlocal pending_thinking_text, pending_signature
+                    if pending_thinking_text is None and pending_signature is None:
+                        return
+                    items.append(convert_reasoning_inputs(pending_thinking_text, pending_signature))
+                    pending_thinking_text = None
+                    pending_signature = None
+
+                for part in msg.parts:
+                    if isinstance(part, message.ThinkingTextPart):
+                        if id(part) not in native_thinking_ids:
+                            continue
+                        emit_reasoning()
+                        pending_thinking_text = part.text
+                        continue
+                    if isinstance(part, message.ThinkingSignaturePart):
+                        if id(part) not in native_thinking_ids:
+                            continue
+                        pending_signature = part.signature
+                        continue
+
+                    emit_reasoning()
+                    if isinstance(part, message.TextPart):
+                        assistant_text_parts.append({"type": "output_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,
+                            }
+                        )
+
+                emit_reasoning()
+                flush_text()
             case _:
-                # Other items may be Metadata
                 continue
 
-    # Cross-model: degrade thinking to plain text with <thinking> tags
     if degraded_thinking_texts:
         degraded_item: responses.ResponseInputItemParam = {
             "type": "message",
@@ -152,21 +174,16 @@ def convert_history_to_input(
     return items
 
 
-def convert_reasoning_inputs(
-    text_content: str | None, encrypted_item: model.ReasoningEncryptedItem
-) -> responses.ResponseInputItemParam:
-    result = {"type": "reasoning", "content": None}
-
+def convert_reasoning_inputs(text_content: str | None, signature: str | None) -> responses.ResponseInputItemParam:
+    result: dict[str, Any] = {"type": "reasoning", "content": None}
     result["summary"] = [
         {
             "type": "summary_text",
             "text": text_content or "",
         }
     ]
-    if encrypted_item.encrypted_content:
-        result["encrypted_content"] = encrypted_item.encrypted_content
-    if encrypted_item.id is not None:
-        result["id"] = encrypted_item.id
+    if signature:
+        result["encrypted_content"] = signature
     return result
 
 

klaude_code/llm/usage.py

@@ -2,7 +2,8 @@ import time
 
 import openai.types
 
-from klaude_code.protocol import llm_param, model
+from klaude_code.const import THROUGHPUT_MIN_DURATION_SEC
+from klaude_code.protocol import llm_param, message, model
 
 
 def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> None:
@@ -18,7 +19,7 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     usage.currency = cost_config.currency
 
     # Non-cached input tokens cost
-    non_cached_input = usage.input_tokens - usage.cached_tokens
+    non_cached_input = max(0, usage.input_tokens - usage.cached_tokens)
     usage.input_cost = (non_cached_input / 1_000_000) * cost_config.input
 
     # Output tokens cost (includes reasoning tokens)
@@ -27,6 +28,9 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     # Cache read cost
     usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * cost_config.cache_read
 
+    # Image generation cost
+    usage.image_cost = (usage.image_tokens / 1_000_000) * cost_config.image
+
 
 class MetadataTracker:
     """Tracks timing and metadata for LLM responses."""
@@ -35,13 +39,9 @@ class MetadataTracker:
         self._request_start_time: float = time.time()
         self._first_token_time: float | None = None
         self._last_token_time: float | None = None
-        self._metadata_item = model.ResponseMetadataItem()
+        self._usage = model.Usage()
         self._cost_config = cost_config
 
-    @property
-    def metadata_item(self) -> model.ResponseMetadataItem:
-        return self._metadata_item
-
     @property
     def first_token_time(self) -> float | None:
         return self._first_token_time
@@ -59,37 +59,59 @@ class MetadataTracker:
 
     def set_usage(self, usage: model.Usage) -> None:
         """Set the usage information."""
-        self._metadata_item.usage = usage
+        preserved = {
+            "response_id": self._usage.response_id,
+            "model_name": self._usage.model_name,
+            "provider": self._usage.provider,
+            "task_duration_s": self._usage.task_duration_s,
+            "created_at": self._usage.created_at,
+        }
+        self._usage = usage.model_copy(update=preserved)
 
     def set_model_name(self, model_name: str) -> None:
         """Set the model name."""
-        self._metadata_item.model_name = model_name
+        self._usage.model_name = model_name
 
     def set_provider(self, provider: str) -> None:
         """Set the provider name."""
-        self._metadata_item.provider = provider
+        self._usage.provider = provider
 
     def set_response_id(self, response_id: str | None) -> None:
         """Set the response ID."""
-        self._metadata_item.response_id = response_id
+        self._usage.response_id = response_id
 
-    def finalize(self) -> model.ResponseMetadataItem:
-        """Finalize and return the metadata item with calculated performance metrics."""
-        if self._metadata_item.usage and self._first_token_time is not None:
-            self._metadata_item.usage.first_token_latency_ms = (
-                self._first_token_time - self._request_start_time
-            ) * 1000
+    def finalize(self) -> model.Usage:
+        """Finalize and return the usage item with calculated performance metrics."""
+        if self._first_token_time is not None:
+            self._usage.first_token_latency_ms = (self._first_token_time - self._request_start_time) * 1000
 
-            if self._last_token_time is not None and self._metadata_item.usage.output_tokens > 0:
+            if self._last_token_time is not None and self._usage.output_tokens > 0:
                 time_duration = self._last_token_time - self._request_start_time
-                if time_duration >= 0.15:
-                    self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
+                if time_duration >= THROUGHPUT_MIN_DURATION_SEC:
+                    self._usage.throughput_tps = self._usage.output_tokens / time_duration
 
         # Calculate cost if config is available
-        if self._metadata_item.usage:
-            calculate_cost(self._metadata_item.usage, self._cost_config)
+        calculate_cost(self._usage, self._cost_config)
+
+        return self._usage
+
+    @property
+    def usage(self) -> model.Usage:
+        return self._usage
 
-        return self._metadata_item
+
+def error_stream_items(
+    metadata_tracker: MetadataTracker,
+    *,
+    error: str,
+    response_id: str | None = None,
+) -> list[message.LLMStreamItem]:
+    metadata_tracker.set_response_id(response_id)
+    metadata = metadata_tracker.finalize()
+    return [
+        message.StreamErrorItem(error=error),
+        message.AssistantMessage(parts=[], response_id=response_id, usage=metadata),
+    ]
 
 
 def convert_usage(
@@ -102,12 +124,17 @@ def convert_usage(
     context_token is set to total_tokens from the API response,
     representing the actual context window usage for this turn.
     """
+    completion_details = usage.completion_tokens_details
+    image_tokens = 0
+    if completion_details is not None:
+        image_tokens = getattr(completion_details, "image_tokens", 0) or 0
+
     return model.Usage(
         input_tokens=usage.prompt_tokens,
         cached_tokens=(usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0) or 0,
-        reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
-        or 0,
+        reasoning_tokens=(completion_details.reasoning_tokens if completion_details else 0) or 0,
         output_tokens=usage.completion_tokens,
+        image_tokens=image_tokens,
         context_size=usage.total_tokens,
         context_limit=context_limit,
         max_tokens=max_tokens,

klaude_code/protocol/__init__.py

@@ -1,4 +1,5 @@
 from klaude_code.protocol import commands as commands
 from klaude_code.protocol import events as events
+from klaude_code.protocol import message as message
 from klaude_code.protocol import model as model
 from klaude_code.protocol import op as op

klaude_code/protocol/events.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from pydantic import BaseModel
 
-from klaude_code.protocol import llm_param, model
+from klaude_code.protocol import llm_param, message, model
 
 """
 Event is how Agent Executor and UI Display communicate.
@@ -50,35 +50,36 @@ class TurnToolCallStartEvent(BaseModel):
     arguments: str
 
 
-class ThinkingEvent(BaseModel):
+class ThinkingDeltaEvent(BaseModel):
     session_id: str
     response_id: str | None = None
     content: str
 
 
-class ThinkingDeltaEvent(BaseModel):
+class AssistantTextDeltaEvent(BaseModel):
     session_id: str
     response_id: str | None = None
     content: str
 
 
-class AssistantMessageDeltaEvent(BaseModel):
+class AssistantImageDeltaEvent(BaseModel):
     session_id: str
     response_id: str | None = None
-    content: str
+    file_path: str
 
 
 class AssistantMessageEvent(BaseModel):
     response_id: str | None = None
     session_id: str
     content: str
+    thinking_text: str | None = None
 
 
 class DeveloperMessageEvent(BaseModel):
     """DeveloperMessages are reminders in user messages or tool results, see: core/reminders.py"""
 
     session_id: str
-    item: model.DeveloperMessageItem
+    item: message.DeveloperMessage
 
 
 class ToolCallEvent(BaseModel):
@@ -98,13 +99,16 @@ class ToolResultEvent(BaseModel):
     ui_extra: model.ToolResultUIExtra | None = None
     status: Literal["success", "error"]
     task_metadata: model.TaskMetadata | None = None  # Sub-agent task metadata
+    # Whether this tool result is the last one emitted in the current turn.
+    # Used by UI renderers to close tree-style prefixes.
+    is_last_in_turn: bool = True
 
 
 class ResponseMetadataEvent(BaseModel):
     """Internal event for turn-level metadata. Not exposed to UI directly."""
 
     session_id: str
-    metadata: model.ResponseMetadataItem
+    metadata: model.Usage
 
 
 class TaskMetadataEvent(BaseModel):
@@ -117,7 +121,7 @@ class TaskMetadataEvent(BaseModel):
 class UserMessageEvent(BaseModel):
     session_id: str
     content: str
-    images: list[model.ImageURLPart] | None = None
+    images: list[message.ImageURLPart] | None = None
 
 
 class WelcomeEvent(BaseModel):
@@ -142,10 +146,10 @@ class ContextUsageEvent(BaseModel):
 
 
 HistoryItemEvent = (
-    ThinkingEvent
-    | TaskStartEvent
+    TaskStartEvent
     | TaskFinishEvent
     | TurnStartEvent  # This event is used for UI to print new empty line
+    | AssistantImageDeltaEvent
     | AssistantMessageEvent
     | ToolCallEvent
     | ToolResultEvent
@@ -167,9 +171,9 @@ class ReplayHistoryEvent(BaseModel):
 Event = (
     TaskStartEvent
     | TaskFinishEvent
-    | ThinkingEvent
     | ThinkingDeltaEvent
-    | AssistantMessageDeltaEvent
+    | AssistantTextDeltaEvent
+    | AssistantImageDeltaEvent
     | AssistantMessageEvent
     | ToolCallEvent
     | ToolResultEvent

klaude_code/protocol/llm_param.py

@@ -4,7 +4,7 @@ from typing import Any, Literal
 from pydantic import BaseModel
 from pydantic.json_schema import JsonSchemaValue
 
-from klaude_code.protocol.model import ConversationItem
+from klaude_code.protocol.message import Message
 
 
 class LLMClientProtocol(Enum):
@@ -39,6 +39,18 @@ class Thinking(BaseModel):
     budget_tokens: int | None = None
 
 
+class ImageConfig(BaseModel):
+    """Image generation config (OpenRouter-compatible fields).
+
+    This is intentionally small and extensible. Additional vendor/model
+    parameters can be stored in `extra`.
+    """
+
+    aspect_ratio: str | None = None
+    image_size: Literal["1K", "2K", "4K"] | None = None
+    extra: dict[str, Any] | None = None
+
+
 class Cost(BaseModel):
     """Cost configuration per million tokens."""
 
@@ -46,6 +58,7 @@ class Cost(BaseModel):
     output: float  # Output token price per million tokens
     cache_read: float = 0.0  # Cache read price per million tokens
     cache_write: float = 0.0  # Cache write price per million tokens (ignored in calculation for now)
+    image: float = 0.0  # Image generation token price per million tokens
     currency: Literal["USD", "CNY"] = "USD"  # Currency for cost display
 
 
@@ -114,6 +127,11 @@ class LLMConfigModelParameter(BaseModel):
     # OpenAI GPT-5
     verbosity: Literal["low", "medium", "high"] | None = None
 
+    # Multimodal output control (OpenRouter image generation)
+    modalities: list[Literal["text", "image"]] | None = None
+
+    image_config: ImageConfig | None = None
+
     # Unified Thinking & Reasoning
     thinking: Thinking | None = None
 
@@ -145,7 +163,7 @@ class LLMCallParameter(LLMConfigModelParameter):
     """
 
     # Agent
-    input: list[ConversationItem]
+    input: list[Message]
     system: str | None = None
     tools: list[ToolSchema] | None = None
     session_id: str | None = None