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

klaude_code/llm/image.py

@@ -0,0 +1,123 @@
+"""Image processing utilities for LLM responses.
+
+This module provides reusable image handling primitives that can be shared
+across different LLM providers and protocols (OpenAI, Anthropic, etc.).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import mimetypes
+import time
+from base64 import b64decode, b64encode
+from binascii import Error as BinasciiError
+from pathlib import Path
+
+from klaude_code.const import (
+    IMAGE_OUTPUT_MAX_BYTES,
+    TOOL_OUTPUT_TRUNCATION_DIR,
+    ProjectPaths,
+    project_key_from_cwd,
+)
+from klaude_code.protocol import message
+
+IMAGE_EXT_BY_MIME: dict[str, str] = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+}
+
+
+def parse_data_url(url: str) -> tuple[str, str, bytes]:
+    """Parse a base64 data URL and return (mime_type, base64_payload, decoded_bytes)."""
+
+    header_and_media = url.split(",", 1)
+    if len(header_and_media) != 2:
+        raise ValueError("Invalid data URL for image: missing comma separator")
+    header, base64_data = header_and_media
+    if not header.startswith("data:"):
+        raise ValueError("Invalid data URL for image: missing data: prefix")
+    if ";base64" not in header:
+        raise ValueError("Invalid data URL for image: missing base64 marker")
+
+    mime_type = header[5:].split(";", 1)[0]
+    base64_payload = base64_data.strip()
+    if base64_payload == "":
+        raise ValueError("Inline image data is empty")
+
+    try:
+        decoded = b64decode(base64_payload, validate=True)
+    except (BinasciiError, ValueError) as exc:
+        raise ValueError("Inline image data is not valid base64") from exc
+
+    return mime_type, base64_payload, decoded
+
+
+def parse_data_url_image(url: str) -> tuple[str, bytes]:
+    """Parse a base64 data URL and return (mime_type, decoded_bytes)."""
+
+    mime_type, _, decoded = parse_data_url(url)
+    return mime_type, decoded
+
+
+def get_assistant_image_output_dir(session_id: str | None) -> Path:
+    """Get the output directory for assistant-generated images."""
+    if session_id:
+        paths = ProjectPaths(project_key=project_key_from_cwd())
+        return paths.images_dir(session_id)
+    return Path(TOOL_OUTPUT_TRUNCATION_DIR) / "images"
+
+
+def save_assistant_image(
+    *, data_url: str, session_id: str | None, response_id: str | None, image_index: int
+) -> message.ImageFilePart:
+    """Decode a data URL image and save it to the session image artifacts directory."""
+
+    mime_type, decoded = parse_data_url_image(data_url)
+
+    if len(decoded) > IMAGE_OUTPUT_MAX_BYTES:
+        decoded_mb = len(decoded) / (1024 * 1024)
+        limit_mb = IMAGE_OUTPUT_MAX_BYTES / (1024 * 1024)
+        raise ValueError(f"Image output size ({decoded_mb:.2f}MB) exceeds limit ({limit_mb:.2f}MB)")
+
+    output_dir = get_assistant_image_output_dir(session_id)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    ext = IMAGE_EXT_BY_MIME.get(mime_type, ".bin")
+    response_part = (response_id or "unknown").replace("/", "_")
+    ts = time.time_ns()
+    file_path = output_dir / f"img-{response_part}-{image_index}-{ts}{ext}"
+    file_path.write_bytes(decoded)
+
+    return message.ImageFilePart(
+        file_path=str(file_path),
+        mime_type=mime_type,
+        byte_size=len(decoded),
+        sha256=hashlib.sha256(decoded).hexdigest(),
+    )
+
+
+def assistant_image_to_data_url(image: message.ImageFilePart) -> str:
+    """Load an assistant image from disk and encode it as a base64 data URL.
+
+    This is primarily used for multi-turn image editing, where providers require
+    sending the previous assistant message (including images) back to the model.
+    """
+
+    file_path = Path(image.file_path)
+    decoded = file_path.read_bytes()
+
+    if len(decoded) > IMAGE_OUTPUT_MAX_BYTES:
+        decoded_mb = len(decoded) / (1024 * 1024)
+        limit_mb = IMAGE_OUTPUT_MAX_BYTES / (1024 * 1024)
+        raise ValueError(f"Assistant image size ({decoded_mb:.2f}MB) exceeds limit ({limit_mb:.2f}MB)")
+
+    mime_type = image.mime_type
+    if not mime_type:
+        guessed, _ = mimetypes.guess_type(str(file_path))
+        mime_type = guessed or "application/octet-stream"
+
+    encoded = b64encode(decoded).decode("ascii")
+    return f"data:{mime_type};base64,{encoded}"

klaude_code/llm/input_common.py

@@ -1,204 +1,166 @@
-"""Common utilities for converting conversation history to LLM input formats.
+"""Common utilities for converting message history to LLM input formats."""
 
-This module provides shared abstractions for providers that require message grouping
-(Anthropic, OpenAI-compatible, OpenRouter). The Responses API doesn't need this
-since it uses a flat item list matching our internal protocol.
-"""
-
-from collections.abc import Iterable, Iterator
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field
-from enum import Enum
 from typing import TYPE_CHECKING
 
-from klaude_code import const
-
 if TYPE_CHECKING:
     from klaude_code.protocol.llm_param import LLMCallParameter, LLMConfigParameter
 
-from klaude_code.protocol import model
+from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.protocol import message
 
 
-class GroupKind(Enum):
-    ASSISTANT = "assistant"
-    USER = "user"
-    TOOL = "tool"
-    DEVELOPER = "developer"
-    OTHER = "other"
+def _empty_image_parts() -> list[message.ImageURLPart]:
+    return []
 
 
 @dataclass
-class UserGroup:
-    """Aggregated user message group (UserMessageItem + DeveloperMessageItem)."""
+class DeveloperAttachment:
+    text: str = ""
+    images: list[message.ImageURLPart] = field(default_factory=_empty_image_parts)
 
-    text_parts: list[str] = field(default_factory=lambda: [])
-    images: list[model.ImageURLPart] = field(default_factory=lambda: [])
 
+def _extract_developer_content(msg: message.DeveloperMessage) -> tuple[str, list[message.ImageURLPart]]:
+    text_parts: list[str] = []
+    images: list[message.ImageURLPart] = []
+    for part in msg.parts:
+        if isinstance(part, message.TextPart):
+            text_parts.append(part.text + "\n")
+        elif isinstance(part, message.ImageURLPart):
+            images.append(part)
+    return "".join(text_parts), images
 
-@dataclass
-class ToolGroup:
-    """Aggregated tool result group (ToolResultItem + trailing DeveloperMessageItems)."""
-
-    tool_result: model.ToolResultItem
-    reminder_texts: list[str] = field(default_factory=lambda: [])
-    reminder_images: list[model.ImageURLPart] = field(default_factory=lambda: [])
 
+def attach_developer_messages(
+    messages: Iterable[message.Message],
+) -> list[tuple[message.Message, DeveloperAttachment]]:
+    """Attach developer messages to the most recent user/tool message.
 
-@dataclass
-class AssistantGroup:
-    """Aggregated assistant message group."""
-
-    text_content: str | None = None
-    tool_calls: list[model.ToolCallItem] = field(default_factory=lambda: [])
-    reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
-
-
-MessageGroup = UserGroup | ToolGroup | AssistantGroup
-
-
-def _kind_of(item: model.ConversationItem) -> GroupKind:
-    if isinstance(
-        item,
-        (model.ReasoningTextItem, model.ReasoningEncryptedItem, model.AssistantMessageItem, model.ToolCallItem),
-    ):
-        return GroupKind.ASSISTANT
-    if isinstance(item, model.UserMessageItem):
-        return GroupKind.USER
-    if isinstance(item, model.ToolResultItem):
-        return GroupKind.TOOL
-    if isinstance(item, model.DeveloperMessageItem):
-        return GroupKind.DEVELOPER
-    return GroupKind.OTHER
-
-
-def group_response_items_gen(
-    items: Iterable[model.ConversationItem],
-) -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
-    """Group response items into sublists with predictable attachment rules.
-
-    - Consecutive assistant-side items (ReasoningTextItem | ReasoningEncryptedItem |
-      AssistantMessageItem | ToolCallItem) group together.
-    - Consecutive UserMessage group together.
-    - Each ToolMessage (ToolResultItem) is a single group, but allow following
-      DeveloperMessage to attach to it.
-    - DeveloperMessage only attaches to the previous UserMessage/ToolMessage group.
+    Developer messages are removed from the output list and their text/images are
+    attached to the previous user/tool message as out-of-band content for provider input.
     """
-    buffer: list[model.ConversationItem] = []
-    buffer_kind: GroupKind | None = None
-
-    def flush() -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
-        """Yield current group and reset buffer state."""
-
-        nonlocal buffer, buffer_kind
-        if buffer_kind is not None and buffer:
-            yield (buffer_kind, buffer)
-        buffer = []
-        buffer_kind = None
+    message_list = list(messages)
+    attachments = [DeveloperAttachment() for _ in message_list]
+    last_user_tool_idx: int | None = None
 
-    for item in items:
-        item_kind = _kind_of(item)
-        if item_kind == GroupKind.OTHER:
+    for idx, msg in enumerate(message_list):
+        if isinstance(msg, (message.UserMessage, message.ToolResultMessage)):
+            last_user_tool_idx = idx
             continue
-
-        # Developer messages only attach to existing user/tool group.
-        if item_kind == GroupKind.DEVELOPER:
-            if buffer_kind in (GroupKind.USER, GroupKind.TOOL):
-                buffer.append(item)
-            continue
-
-        # Start a new group when there is no active buffer yet.
-        if buffer_kind is None:
-            buffer_kind = GroupKind.TOOL if item_kind == GroupKind.TOOL else item_kind
-            buffer = [item]
-            continue
-
-        # Tool messages always form a standalone group.
-        if item_kind == GroupKind.TOOL:
-            yield from flush()
-            buffer_kind = GroupKind.TOOL
-            buffer = [item]
-            continue
-
-        # Same non-tool kind: extend current group.
-        if item_kind == buffer_kind:
-            buffer.append(item)
+        if isinstance(msg, message.DeveloperMessage):
+            if last_user_tool_idx is None:
+                continue
+            dev_text, dev_images = _extract_developer_content(msg)
+            attachment = attachments[last_user_tool_idx]
+            attachment.text += dev_text
+            attachment.images.extend(dev_images)
+
+    result: list[tuple[message.Message, DeveloperAttachment]] = []
+    for idx, msg in enumerate(message_list):
+        if isinstance(msg, message.DeveloperMessage):
             continue
+        result.append((msg, attachments[idx]))
 
-        # Different non-tool kind: close previous group and start a new one.
-        yield from flush()
-        buffer_kind = item_kind
-        buffer = [item]
+    return result
 
-    if buffer_kind is not None and buffer:
-        yield (buffer_kind, buffer)
 
+def merge_reminder_text(tool_output: str | None, reminder_text: str) -> str:
+    """Merge tool output with reminder text."""
+    base = tool_output or ""
+    if reminder_text:
+        base += "\n" + reminder_text
+    return base
 
-def parse_message_groups(history: list[model.ConversationItem]) -> list[MessageGroup]:
-    """Parse conversation history into aggregated message groups.
 
-    This is the shared grouping logic for Anthropic, OpenAI-compatible, and OpenRouter.
-    Each provider then converts these groups to their specific API format.
-    """
-    groups: list[MessageGroup] = []
-
-    for kind, items in group_response_items_gen(history):
-        match kind:
-            case GroupKind.OTHER:
+def collect_text_content(parts: list[message.Part]) -> str:
+    return "".join(part.text for part in parts if isinstance(part, message.TextPart))
+
+
+def build_chat_content_parts(
+    msg: message.UserMessage,
+    attachment: DeveloperAttachment,
+) -> list[dict[str, object]]:
+    parts: list[dict[str, object]] = []
+    for part in msg.parts:
+        if isinstance(part, message.TextPart):
+            parts.append({"type": "text", "text": part.text})
+        elif isinstance(part, message.ImageURLPart):
+            parts.append({"type": "image_url", "image_url": {"url": part.url}})
+    if attachment.text:
+        parts.append({"type": "text", "text": attachment.text})
+    for image in attachment.images:
+        parts.append({"type": "image_url", "image_url": {"url": image.url}})
+    if not parts:
+        parts.append({"type": "text", "text": ""})
+    return parts
+
+
+def build_tool_message(
+    msg: message.ToolResultMessage,
+    attachment: DeveloperAttachment,
+) -> dict[str, object]:
+    merged_text = merge_reminder_text(
+        msg.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
+        attachment.text,
+    )
+    return {
+        "role": "tool",
+        "content": [{"type": "text", "text": merged_text}],
+        "tool_call_id": msg.call_id,
+    }
+
+
+def build_assistant_common_fields(
+    msg: message.AssistantMessage,
+    *,
+    image_to_data_url: Callable[[message.ImageFilePart], str],
+) -> dict[str, object]:
+    result: dict[str, object] = {}
+    images = [part for part in msg.parts if isinstance(part, message.ImageFilePart)]
+    if images:
+        result["images"] = [
+            {
+                "image_url": {
+                    "url": image_to_data_url(image),
+                }
+            }
+            for image in images
+        ]
+
+    tool_calls = [part for part in msg.parts if isinstance(part, message.ToolCallPart)]
+    if tool_calls:
+        result["tool_calls"] = [
+            {
+                "id": tc.call_id,
+                "type": "function",
+                "function": {
+                    "name": tc.tool_name,
+                    "arguments": tc.arguments_json,
+                },
+            }
+            for tc in tool_calls
+        ]
+    return result
+
+
+def split_thinking_parts(
+    msg: message.AssistantMessage,
+    model_name: str | None,
+) -> tuple[list[message.ThinkingTextPart | message.ThinkingSignaturePart], list[str]]:
+    native_parts: list[message.ThinkingTextPart | message.ThinkingSignaturePart] = []
+    degraded_texts: list[str] = []
+    for part in msg.parts:
+        if isinstance(part, message.ThinkingTextPart):
+            if part.model_id and model_name and part.model_id != model_name:
+                degraded_texts.append(part.text)
                 continue
-            case GroupKind.USER:
-                group = UserGroup()
-                for item in items:
-                    if isinstance(item, (model.UserMessageItem, model.DeveloperMessageItem)):
-                        if item.content:
-                            group.text_parts.append(item.content + "\n")
-                        if item.images:
-                            group.images.extend(item.images)
-                groups.append(group)
-
-            case GroupKind.TOOL:
-                if not items or not isinstance(items[0], model.ToolResultItem):
-                    continue
-                tool_result = items[0]
-                group = ToolGroup(tool_result=tool_result)
-                for item in items[1:]:
-                    if isinstance(item, model.DeveloperMessageItem):
-                        if item.content:
-                            group.reminder_texts.append(item.content)
-                        if item.images:
-                            group.reminder_images.extend(item.images)
-                groups.append(group)
-
-            case GroupKind.ASSISTANT:
-                group = AssistantGroup()
-                for item in items:
-                    match item:
-                        case model.AssistantMessageItem():
-                            if item.content:
-                                if group.text_content is None:
-                                    group.text_content = item.content
-                                else:
-                                    group.text_content += item.content
-                        case model.ToolCallItem():
-                            group.tool_calls.append(item)
-                        case model.ReasoningTextItem():
-                            group.reasoning_items.append(item)
-                        case model.ReasoningEncryptedItem():
-                            group.reasoning_items.append(item)
-                        case _:
-                            pass
-                groups.append(group)
-
-            case GroupKind.DEVELOPER:
-                pass
-
-    return groups
-
-
-def merge_reminder_text(tool_output: str | None, reminder_texts: list[str]) -> str:
-    """Merge tool output with reminder texts."""
-    base = tool_output or ""
-    if reminder_texts:
-        base += "\n" + "\n".join(reminder_texts)
-    return base
+            native_parts.append(part)
+        elif isinstance(part, message.ThinkingSignaturePart):
+            if part.model_id and model_name and part.model_id != model_name:
+                continue
+            native_parts.append(part)
+    return native_parts, degraded_texts
 
 
 def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter") -> "LLMCallParameter":
@@ -215,19 +177,4 @@ def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter
         param.verbosity = config.verbosity
     if param.thinking is None:
         param.thinking = config.thinking
-    if param.provider_routing is None:
-        param.provider_routing = config.provider_routing
-
-    if param.model is None:
-        raise ValueError("Model is required")
-    if param.max_tokens is None:
-        param.max_tokens = const.DEFAULT_MAX_TOKENS
-    if param.temperature is None:
-        param.temperature = const.DEFAULT_TEMPERATURE
-    if param.thinking is not None and param.thinking.type == "enabled" and param.thinking.budget_tokens is None:
-        param.thinking.budget_tokens = const.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS
-
-    if param.model and "gpt-5" in param.model:
-        param.temperature = 1.0  # Required for GPT-5
-
     return param

klaude_code/llm/openai_compatible/client.py

@@ -6,13 +6,14 @@ import httpx
 import openai
 from openai.types.chat.completion_create_params import CompletionCreateParamsStreaming
 
+from klaude_code.const import LLM_HTTP_TIMEOUT_CONNECT, LLM_HTTP_TIMEOUT_READ, LLM_HTTP_TIMEOUT_TOTAL
 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_history_to_input, convert_tool_schema
 from klaude_code.llm.openai_compatible.stream import DefaultReasoningHandler, parse_chat_completions_stream
 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, log_debug
 
 
@@ -56,13 +57,17 @@ class OpenAICompatibleClient(LLMClientABC):
                 api_key=config.api_key,
                 azure_endpoint=str(config.base_url),
                 api_version=config.azure_api_version,
-                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+                timeout=httpx.Timeout(
+                    LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ
+                ),
             )
         else:
             client = openai.AsyncOpenAI(
                 api_key=config.api_key,
                 base_url=config.base_url,
-                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+                timeout=httpx.Timeout(
+                    LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ
+                ),
             )
         self.client: openai.AsyncAzureOpenAI | openai.AsyncOpenAI = client
 
@@ -72,12 +77,17 @@ class OpenAICompatibleClient(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 = build_payload(param)
+        try:
+            payload, extra_body = 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
         extra_headers: dict[str, str] = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
 
         log_debug(
@@ -93,8 +103,8 @@ class OpenAICompatibleClient(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 = DefaultReasoningHandler(

klaude_code/llm/openai_compatible/input.py

@@ -6,89 +6,59 @@
 from openai.types import chat
 from openai.types.chat import ChatCompletionContentPartParam
 
-from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
-from klaude_code.protocol import llm_param, model
-
-
-def user_group_to_openai_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
-    """Convert a UserGroup to an OpenAI-compatible chat message."""
-    parts: list[ChatCompletionContentPartParam] = []
-    for text in group.text_parts:
-        parts.append({"type": "text", "text": text + "\n"})
-    for image in group.images:
-        parts.append({"type": "image_url", "image_url": {"url": image.image_url.url}})
-    if not parts:
-        parts.append({"type": "text", "text": ""})
-    return {"role": "user", "content": parts}
-
-
-def tool_group_to_openai_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
-    """Convert a ToolGroup to an OpenAI-compatible chat message."""
-    merged_text = merge_reminder_text(
-        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
-        group.reminder_texts,
-    )
-    return {
-        "role": "tool",
-        "content": [{"type": "text", "text": merged_text}],
-        "tool_call_id": group.tool_result.call_id,
-    }
-
-
-def _assistant_group_to_message(
-    group: AssistantGroup,
-) -> chat.ChatCompletionMessageParam:
+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,
+)
+from klaude_code.protocol import llm_param, message
+
+
+def _assistant_message_to_openai(msg: message.AssistantMessage) -> chat.ChatCompletionMessageParam:
     assistant_message: dict[str, object] = {"role": "assistant"}
 
-    if group.text_content:
-        assistant_message["content"] = group.text_content
-
-    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
-        ]
+    text_content = collect_text_content(msg.parts)
+    if text_content:
+        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
 
 
 def build_user_content_parts(
-    images: list[model.ImageURLPart],
+    images: list[message.ImageURLPart],
 ) -> list[ChatCompletionContentPartParam]:
     """Build content parts for images only. Used by OpenRouter."""
-    return [{"type": "image_url", "image_url": {"url": image.image_url.url}} for image in images]
+    return [{"type": "image_url", "image_url": {"url": image.url}} for image in images]
 
 
 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. Not used in OpenAI-compatible, kept for API consistency.
-    """
+    """Convert a list of messages to chat completion params."""
+    del model_name
     messages: list[chat.ChatCompletionMessageParam] = [{"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))
+    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})
+            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_openai(msg))
+            case _:
+                continue
 
     return messages