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

klaude_code/llm/openai_compatible/stream.py

@@ -4,7 +4,7 @@ This module provides reusable primitives for OpenAI-compatible providers:
 
 - ``StreamStateManager``: accumulates assistant content and tool calls.
 - ``ReasoningHandlerABC``: provider-specific reasoning extraction + buffering.
-- ``parse_chat_completions_stream``: shared stream loop that emits ConversationItems.
+- ``parse_chat_completions_stream``: shared stream loop that emits stream/history items.
 
 OpenRouter uses the same OpenAI Chat Completions API surface but differs in
 how reasoning is represented (``reasoning_details`` vs ``reasoning_content``).
@@ -24,9 +24,10 @@ import pydantic
 from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
+from klaude_code.llm.image import save_assistant_image
 from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
 from klaude_code.llm.usage import MetadataTracker, convert_usage
-from klaude_code.protocol import llm_param, model
+from klaude_code.protocol import llm_param, message, model
 
 StreamStage = Literal["waiting", "reasoning", "assistant", "tool"]
 
@@ -42,62 +43,55 @@ class StreamStateManager:
         self,
         param_model: str,
         response_id: str | None = None,
-        reasoning_flusher: Callable[[], list[model.ConversationItem]] | None = None,
+        reasoning_flusher: Callable[[], list[message.Part]] | None = None,
     ):
         self.param_model = param_model
         self.response_id = response_id
         self.stage: StreamStage = "waiting"
-        self.accumulated_reasoning: list[str] = []
         self.accumulated_content: list[str] = []
+        self.accumulated_images: list[message.ImageFilePart] = []
         self.accumulated_tool_calls: ToolCallAccumulatorABC = BasicToolCallAccumulator()
         self.emitted_tool_start_indices: set[int] = set()
         self._reasoning_flusher = reasoning_flusher
+        self.parts: list[message.Part] = []
+        self.stop_reason: model.StopReason | None = None
 
     def set_response_id(self, response_id: str) -> None:
         """Set the response ID once received from the stream."""
         self.response_id = response_id
-        self.accumulated_tool_calls.response_id = response_id  # pyright: ignore[reportAttributeAccessIssue]
+        self.accumulated_tool_calls.set_response_id(response_id)
 
-    def flush_reasoning(self) -> list[model.ConversationItem]:
-        """Flush accumulated reasoning content and return items."""
+    def flush_reasoning(self) -> None:
+        """Flush accumulated reasoning content into parts."""
         if self._reasoning_flusher is not None:
-            return self._reasoning_flusher()
-        if not self.accumulated_reasoning:
-            return []
-        item = model.ReasoningTextItem(
-            content="".join(self.accumulated_reasoning),
-            response_id=self.response_id,
-            model=self.param_model,
-        )
-        self.accumulated_reasoning = []
-        return [item]
-
-    def flush_assistant(self) -> list[model.ConversationItem]:
-        """Flush accumulated assistant content and return items."""
-        if not self.accumulated_content:
-            return []
-        item = model.AssistantMessageItem(
-            content="".join(self.accumulated_content),
-            response_id=self.response_id,
-        )
+            self.parts.extend(self._reasoning_flusher())
+
+    def flush_assistant(self) -> None:
+        """Flush accumulated assistant content into parts."""
+        if not self.accumulated_content and not self.accumulated_images:
+            return
+        if self.accumulated_content:
+            self.parts.append(message.TextPart(text="".join(self.accumulated_content)))
+        if self.accumulated_images:
+            self.parts.extend(self.accumulated_images)
         self.accumulated_content = []
-        return [item]
+        self.accumulated_images = []
+        return
 
-    def flush_tool_calls(self) -> list[model.ToolCallItem]:
-        """Flush accumulated tool calls and return items."""
-        items: list[model.ToolCallItem] = self.accumulated_tool_calls.get()
+    def flush_tool_calls(self) -> None:
+        """Flush accumulated tool calls into parts."""
+        items = self.accumulated_tool_calls.get()
         if items:
-            self.accumulated_tool_calls.chunks_by_step = []  # pyright: ignore[reportAttributeAccessIssue]
-        return items
+            self.parts.extend(items)
+            self.accumulated_tool_calls.reset()
 
-    def flush_all(self) -> list[model.ConversationItem]:
+    def flush_all(self) -> list[message.Part]:
         """Flush all accumulated content in order: reasoning, assistant, tool calls."""
-        items: list[model.ConversationItem] = []
-        items.extend(self.flush_reasoning())
-        items.extend(self.flush_assistant())
+        self.flush_reasoning()
+        self.flush_assistant()
         if self.stage == "tool":
-            items.extend(self.flush_tool_calls())
-        return items
+            self.flush_tool_calls()
+        return list(self.parts)
 
 
 @dataclass(slots=True)
@@ -105,7 +99,7 @@ class ReasoningDeltaResult:
     """Result of processing a single provider delta for reasoning signals."""
 
     handled: bool
-    outputs: list[str | model.ConversationItem]
+    outputs: list[str | message.Part]
 
 
 class ReasoningHandlerABC(ABC):
@@ -120,7 +114,7 @@ class ReasoningHandlerABC(ABC):
         """Process a single delta and return ordered reasoning outputs."""
 
     @abstractmethod
-    def flush(self) -> list[model.ConversationItem]:
+    def flush(self) -> list[message.Part]:
         """Flush buffered reasoning content (usually at stage transition/finalize)."""
 
 
@@ -148,18 +142,29 @@ class DefaultReasoningHandler(ReasoningHandlerABC):
         self._accumulated.append(text)
         return ReasoningDeltaResult(handled=True, outputs=[text])
 
-    def flush(self) -> list[model.ConversationItem]:
+    def flush(self) -> list[message.Part]:
         if not self._accumulated:
             return []
-        item = model.ReasoningTextItem(
-            content="".join(self._accumulated),
-            response_id=self._response_id,
-            model=self._param_model,
+        item = message.ThinkingTextPart(
+            text="".join(self._accumulated),
+            model_id=self._param_model,
         )
         self._accumulated = []
         return [item]
 
 
+def _map_finish_reason(reason: str) -> model.StopReason | None:
+    mapping: dict[str, model.StopReason] = {
+        "stop": "stop",
+        "length": "length",
+        "tool_calls": "tool_use",
+        "content_filter": "error",
+        "error": "error",
+        "cancelled": "aborted",
+    }
+    return mapping.get(reason)
+
+
 async def parse_chat_completions_stream(
     stream: AsyncStream[ChatCompletionChunk],
     *,
@@ -167,8 +172,8 @@ async def parse_chat_completions_stream(
     metadata_tracker: MetadataTracker,
     reasoning_handler: ReasoningHandlerABC,
     on_event: Callable[[object], None] | None = None,
-) -> AsyncGenerator[model.ConversationItem]:
-    """Parse OpenAI Chat Completions stream into ConversationItems.
+) -> AsyncGenerator[message.LLMStreamItem]:
+    """Parse OpenAI Chat Completions stream into stream items.
 
     This is shared by OpenAI-compatible and OpenRouter clients.
     """
@@ -178,6 +183,20 @@ async def parse_chat_completions_stream(
         reasoning_flusher=reasoning_handler.flush,
     )
 
+    def _extract_image_url(image_obj: object) -> str | None:
+        image_url = getattr(image_obj, "image_url", None)
+        if image_url is not None:
+            url = getattr(image_url, "url", None)
+            return str(url) if isinstance(url, str) else None
+        if isinstance(image_obj, dict):
+            image_dict = cast(dict[str, Any], image_obj)
+            url_dict_raw = image_dict.get("image_url")
+            if isinstance(url_dict_raw, dict):
+                url_dict = cast(dict[str, Any], url_dict_raw)
+                url_raw = url_dict.get("url")
+                return url_raw if isinstance(url_raw, str) else None
+        return None
+
     try:
         async for event in stream:
             if on_event is not None:
@@ -186,7 +205,6 @@ async def parse_chat_completions_stream(
             if not state.response_id and (event_id := getattr(event, "id", None)):
                 state.set_response_id(str(event_id))
                 reasoning_handler.set_response_id(str(event_id))
-                yield model.StartItem(response_id=str(event_id))
 
             if (event_usage := getattr(event, "usage", None)) is not None:
                 metadata_tracker.set_usage(convert_usage(event_usage, param.context_limit, param.max_tokens))
@@ -212,6 +230,10 @@ async def parse_chat_completions_stream(
             if delta is None:
                 continue
 
+            finish_reason = getattr(choice0, "finish_reason", None)
+            if isinstance(finish_reason, str):
+                state.stop_reason = _map_finish_reason(finish_reason)
+
             # Reasoning
             reasoning_result = reasoning_handler.on_delta(delta)
             if reasoning_result.handled:
@@ -221,22 +243,51 @@ async def parse_chat_completions_stream(
                         if not output:
                             continue
                         metadata_tracker.record_token()
-                        yield model.ReasoningTextDelta(content=output, response_id=state.response_id)
+                        yield message.ThinkingTextDelta(content=output, response_id=state.response_id)
                     else:
-                        yield output
+                        state.parts.append(output)
 
             # Assistant
+            images = getattr(delta, "images", None)
+            if isinstance(images, list) and images:
+                images_list = cast(list[object], images)
+                metadata_tracker.record_token()
+                if state.stage == "reasoning":
+                    state.flush_reasoning()
+                elif state.stage == "tool":
+                    state.flush_tool_calls()
+                state.stage = "assistant"
+                for image_obj in images_list:
+                    url = _extract_image_url(image_obj)
+                    if not url:
+                        continue
+                    if not url.startswith("data:"):
+                        # Only data URLs are supported for now.
+                        continue
+                    try:
+                        assistant_image = save_assistant_image(
+                            data_url=url,
+                            session_id=param.session_id,
+                            response_id=state.response_id,
+                            image_index=len(state.accumulated_images),
+                        )
+                    except ValueError as exc:
+                        yield message.StreamErrorItem(error=str(exc))
+                        return
+                    state.accumulated_images.append(assistant_image)
+                    yield message.AssistantImageDelta(
+                        response_id=state.response_id, file_path=assistant_image.file_path
+                    )
+
             if (content := getattr(delta, "content", None)) and (state.stage == "assistant" or str(content).strip()):
                 metadata_tracker.record_token()
                 if state.stage == "reasoning":
-                    for item in state.flush_reasoning():
-                        yield item
+                    state.flush_reasoning()
                 elif state.stage == "tool":
-                    for item in state.flush_tool_calls():
-                        yield item
+                    state.flush_tool_calls()
                 state.stage = "assistant"
                 state.accumulated_content.append(str(content))
-                yield model.AssistantMessageDelta(
+                yield message.AssistantTextDelta(
                     content=str(content),
                     response_id=state.response_id,
                 )
@@ -245,29 +296,30 @@ async def parse_chat_completions_stream(
             if (tool_calls := getattr(delta, "tool_calls", None)) and len(tool_calls) > 0:
                 metadata_tracker.record_token()
                 if state.stage == "reasoning":
-                    for item in state.flush_reasoning():
-                        yield item
+                    state.flush_reasoning()
                 elif state.stage == "assistant":
-                    for item in state.flush_assistant():
-                        yield item
+                    state.flush_assistant()
                 state.stage = "tool"
                 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 model.ToolCallStartItem(
+                        yield message.ToolCallStartItem(
                             response_id=state.response_id,
                             call_id=tc.id or "",
                             name=tc.function.name,
                         )
                 state.accumulated_tool_calls.add(tool_calls)
     except (openai.OpenAIError, httpx.HTTPError) as e:
-        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+        yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
-    flushed_items = state.flush_all()
-    if flushed_items:
+    parts = state.flush_all()
+    if parts:
         metadata_tracker.record_token()
-    for item in flushed_items:
-        yield item
-
     metadata_tracker.set_response_id(state.response_id)
-    yield metadata_tracker.finalize()
+    metadata = metadata_tracker.finalize()
+    yield message.AssistantMessage(
+        parts=parts,
+        response_id=state.response_id,
+        usage=metadata,
+        stop_reason=state.stop_reason,
+    )

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
 from pydantic import BaseModel, Field
 
-from klaude_code.protocol import model
+from klaude_code.protocol import message
 from klaude_code.trace.log import log_debug
 
 
@@ -28,7 +28,15 @@ class ToolCallAccumulatorABC(ABC):
         pass
 
     @abstractmethod
-    def get(self) -> list[model.ToolCallItem]:
+    def get(self) -> list[message.ToolCallPart]:
+        pass
+
+    @abstractmethod
+    def set_response_id(self, response_id: str | None) -> None:
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
         pass
 
 
@@ -69,8 +77,8 @@ class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
     def add(self, chunks: list[ChoiceDeltaToolCall]) -> None:
         self.chunks_by_step.append(chunks)
 
-    def get(self) -> list[model.ToolCallItem]:
-        result: list[model.ToolCallItem] = []
+    def get(self) -> list[message.ToolCallPart]:
+        result: list[message.ToolCallPart] = []
         current_index = -1
         for current_step in self.chunks_by_step:
             if len(current_step) == 0:
@@ -79,18 +87,22 @@ class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
             if first_chunk.index != current_index:
                 current_index = first_chunk.index
                 result.append(
-                    model.ToolCallItem(
-                        id=first_chunk.id,
-                        name="",
-                        arguments="",
+                    message.ToolCallPart(
                         call_id=first_chunk.id or "",
-                        response_id=self.response_id,
+                        tool_name="",
+                        arguments_json="",
                     )
                 )
             if first_chunk.function is None:
                 continue
             if first_chunk.function.name:
-                result[-1].name = normalize_tool_name(first_chunk.function.name)
+                result[-1].tool_name = normalize_tool_name(first_chunk.function.name)
             if first_chunk.function.arguments:
-                result[-1].arguments += first_chunk.function.arguments
+                result[-1].arguments_json += first_chunk.function.arguments
         return result
+
+    def set_response_id(self, response_id: str | None) -> None:
+        self.response_id = response_id
+
+    def reset(self) -> None:
+        self.chunks_by_step = []

klaude_code/llm/openrouter/client.py

@@ -1,11 +1,19 @@
 import json
 from collections.abc import AsyncGenerator
-from typing import Any, override
+from typing import Any, cast, override
 
 import httpx
 import openai
 from openai.types.chat.completion_create_params import CompletionCreateParamsStreaming
 
+from klaude_code.const import (
+    ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING,
+    ANTHROPIC_BETA_INTERLEAVED_THINKING,
+    LLM_HTTP_TIMEOUT_CONNECT,
+    LLM_HTTP_TIMEOUT_READ,
+    LLM_HTTP_TIMEOUT_TOTAL,
+    OPENROUTER_BASE_URL,
+)
 from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.openai_compatible.input import convert_tool_schema
@@ -14,7 +22,7 @@ from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude
 from klaude_code.llm.openrouter.reasoning import ReasoningStreamHandler
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker
-from klaude_code.protocol import llm_param, model
+from klaude_code.protocol import llm_param, message
 from klaude_code.trace import DebugType, is_debug_enabled, log_debug
 
 
@@ -28,6 +36,16 @@ def build_payload(
     extra_body: dict[str, object] = {
         "usage": {"include": True},  # To get the cache tokens at the end of the response
     }
+
+    if param.modalities:
+        extra_body["modalities"] = list(param.modalities)
+    if param.image_config is not None:
+        image_config = param.image_config.model_dump(exclude_none=True)
+        extra_raw = image_config.pop("extra", None)
+        extra_dict: dict[str, Any] | None = cast(dict[str, Any], extra_raw) if isinstance(extra_raw, dict) else None
+        if extra_dict is not None and extra_dict:
+            image_config.update(extra_dict)
+        extra_body["image_config"] = image_config
     if is_debug_enabled():
         extra_body["debug"] = {
             "echo_upstream_body": True
@@ -49,7 +67,9 @@ def build_payload(
         extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
 
     if is_claude_model(param.model):
-        extra_headers["x-anthropic-beta"] = "fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14"
+        extra_headers["x-anthropic-beta"] = (
+            f"{ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING},{ANTHROPIC_BETA_INTERLEAVED_THINKING}"
+        )
 
     payload: CompletionCreateParamsStreaming = {
         "model": str(param.model),
@@ -72,8 +92,8 @@ class OpenRouterClient(LLMClientABC):
         super().__init__(config)
         client = openai.AsyncOpenAI(
             api_key=config.api_key,
-            base_url="https://openrouter.ai/api/v1",
-            timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            base_url=OPENROUTER_BASE_URL,
+            timeout=httpx.Timeout(LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ),
         )
         self.client: openai.AsyncOpenAI = client
 
@@ -83,12 +103,17 @@ class OpenRouterClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[message.LLMStreamItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        payload, extra_body, extra_headers = build_payload(param)
+        try:
+            payload, extra_body, extra_headers = build_payload(param)
+        except (ValueError, OSError) as e:
+            yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield message.AssistantMessage(parts=[], response_id=None, usage=metadata_tracker.finalize())
+            return
 
         log_debug(
             json.dumps({**payload, **extra_body}, ensure_ascii=False, default=str),
@@ -103,8 +128,8 @@ class OpenRouterClient(LLMClientABC):
                 extra_headers=extra_headers,
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
-            yield metadata_tracker.finalize()
+            yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield message.AssistantMessage(parts=[], response_id=None, usage=metadata_tracker.finalize())
             return
 
         reasoning_handler = ReasoningStreamHandler(

klaude_code/llm/openrouter/input.py

@@ -8,9 +8,16 @@
 
 from openai.types import chat
 
-from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, parse_message_groups
-from klaude_code.llm.openai_compatible.input import tool_group_to_openai_message, user_group_to_openai_message
-from klaude_code.protocol import model
+from klaude_code.llm.image import assistant_image_to_data_url
+from klaude_code.llm.input_common import (
+    attach_developer_messages,
+    build_assistant_common_fields,
+    build_chat_content_parts,
+    build_tool_message,
+    collect_text_content,
+    split_thinking_parts,
+)
+from klaude_code.protocol import message
 
 
 def is_claude_model(model_name: str | None) -> bool:
@@ -25,64 +32,42 @@ def is_gemini_model(model_name: str | None) -> bool:
     return model_name is not None and model_name.startswith("google/gemini")
 
 
-def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -> chat.ChatCompletionMessageParam:
+def _assistant_message_to_openrouter(
+    msg: message.AssistantMessage, model_name: str | None
+) -> chat.ChatCompletionMessageParam:
     assistant_message: dict[str, object] = {"role": "assistant"}
-
-    if group.tool_calls:
-        assistant_message["tool_calls"] = [
-            {
-                "id": tc.call_id,
-                "type": "function",
-                "function": {
-                    "name": tc.name,
-                    "arguments": tc.arguments,
-                },
-            }
-            for tc in group.tool_calls
-        ]
-
-    # Handle reasoning for OpenRouter (reasoning_details array).
-    # The order of items in reasoning_details must match the original
-    # stream order from the provider, so we iterate reasoning_items
-    # instead of the separated reasoning_text / reasoning_encrypted lists.
-    # For cross-model scenarios, degrade thinking to plain text.
+    assistant_message.update(build_assistant_common_fields(msg, image_to_data_url=assistant_image_to_data_url))
     reasoning_details: list[dict[str, object]] = []
-    degraded_thinking_texts: list[str] = []
-    for item in group.reasoning_items:
-        if model_name != item.model:
-            # Cross-model: collect thinking text for degradation
-            if isinstance(item, model.ReasoningTextItem) and item.content:
-                degraded_thinking_texts.append(item.content)
-            continue
-        if isinstance(item, model.ReasoningEncryptedItem):
-            if item.encrypted_content and len(item.encrypted_content) > 0:
-                reasoning_details.append(
-                    {
-                        "id": item.id,
-                        "type": "reasoning.encrypted",
-                        "data": item.encrypted_content,
-                        "format": item.format,
-                        "index": len(reasoning_details),
-                    }
-                )
-        elif isinstance(item, model.ReasoningTextItem):
+    native_thinking_parts, degraded_thinking_texts = split_thinking_parts(msg, model_name)
+    for part in native_thinking_parts:
+        if isinstance(part, message.ThinkingTextPart):
             reasoning_details.append(
                 {
-                    "id": item.id,
+                    "id": part.id,
                     "type": "reasoning.text",
-                    "text": item.content,
+                    "text": part.text,
+                    "index": len(reasoning_details),
+                }
+            )
+        elif isinstance(part, message.ThinkingSignaturePart) and part.signature:
+            reasoning_details.append(
+                {
+                    "id": part.id,
+                    "type": "reasoning.encrypted",
+                    "data": part.signature,
+                    "format": part.format,
                     "index": len(reasoning_details),
                 }
             )
     if reasoning_details:
         assistant_message["reasoning_details"] = reasoning_details
 
-    # Build content with optional degraded thinking prefix
     content_parts: list[str] = []
     if degraded_thinking_texts:
         content_parts.append("<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>")
-    if group.text_content:
-        content_parts.append(group.text_content)
+    text_content = collect_text_content(msg.parts)
+    if text_content:
+        content_parts.append(text_content)
     if content_parts:
         assistant_message["content"] = "\n".join(content_parts)
 
@@ -104,18 +89,11 @@ def _add_cache_control(messages: list[chat.ChatCompletionMessageParam], use_cach
 
 
 def convert_history_to_input(
-    history: list[model.ConversationItem],
+    history: list[message.Message],
     system: str | None = None,
     model_name: str | None = None,
 ) -> list[chat.ChatCompletionMessageParam]:
-    """
-    Convert a list of conversation items to a list of chat completion message params.
-
-    Args:
-        history: List of conversation items.
-        system: System message.
-        model_name: Model name. Used to verify that signatures are valid for the same model.
-    """
+    """Convert a list of messages to chat completion params."""
     use_cache_control = is_claude_model(model_name) or is_gemini_model(model_name)
 
     messages: list[chat.ChatCompletionMessageParam] = (
@@ -135,14 +113,35 @@ def convert_history_to_input(
         else ([{"role": "system", "content": system}] if system else [])
     )
 
-    for group in parse_message_groups(history):
-        match group:
-            case UserGroup():
-                messages.append(user_group_to_openai_message(group))
-            case ToolGroup():
-                messages.append(tool_group_to_openai_message(group))
-            case AssistantGroup():
-                messages.append(_assistant_group_to_message(group, model_name))
+    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:
+                    if use_cache_control:
+                        messages.append(
+                            {
+                                "role": "system",
+                                "content": [
+                                    {
+                                        "type": "text",
+                                        "text": system_text,
+                                        "cache_control": {"type": "ephemeral"},
+                                    }
+                                ],
+                            }
+                        )
+                    else:
+                        messages.append({"role": "system", "content": system_text})
+            case message.UserMessage():
+                parts = build_chat_content_parts(msg, attachment)
+                messages.append({"role": "user", "content": parts})
+            case message.ToolResultMessage():
+                messages.append(build_tool_message(msg, attachment))
+            case message.AssistantMessage():
+                messages.append(_assistant_message_to_openrouter(msg, model_name))
+            case _:
+                continue
 
     _add_cache_control(messages, use_cache_control)
     return messages