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

klaude_code/llm/client.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator
 from typing import ParamSpec, TypeVar, cast
 
-from klaude_code.protocol import llm_param, model
+from klaude_code.protocol import llm_param, message
 
 
 class LLMClientABC(ABC):
@@ -15,9 +15,10 @@ class LLMClientABC(ABC):
         pass
 
     @abstractmethod
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[message.LLMStreamItem]:
+        if False:  # pragma: no cover
+            yield cast(message.LLMStreamItem, None)
         raise NotImplementedError
-        yield cast(model.ConversationItem, None)
 
     def get_llm_config(self) -> llm_param.LLMConfigParameter:
         return self._config

klaude_code/llm/codex/client.py

@@ -12,13 +12,20 @@ from openai.types.responses.response_create_params import ResponseCreateParamsSt
 from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
 from klaude_code.auth.codex.oauth import CodexOAuth
 from klaude_code.auth.codex.token_manager import CodexTokenManager
+from klaude_code.const import (
+    CODEX_BASE_URL,
+    CODEX_USER_AGENT,
+    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.registry import register
 from klaude_code.llm.responses.client import parse_responses_stream
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
-from klaude_code.llm.usage import MetadataTracker
-from klaude_code.protocol import llm_param, model
+from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.protocol import llm_param, message
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -57,12 +64,9 @@ def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStre
     return payload
 
 
-# Codex API configuration
-CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"
 CODEX_HEADERS = {
     "originator": "codex_cli_rs",
-    # Mocked Codex-style user agent string
-    "User-Agent": "codex_cli_rs/0.0.0-klaude",
+    "User-Agent": CODEX_USER_AGENT,
     "OpenAI-Beta": "responses=experimental",
 }
 
@@ -90,7 +94,7 @@ class CodexClient(LLMClientABC):
         return AsyncOpenAI(
             api_key=state.access_token,
             base_url=CODEX_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),
             default_headers={
                 **CODEX_HEADERS,
                 "chatgpt-account-id": state.account_id,
@@ -114,7 +118,7 @@ class CodexClient(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]:
         # Ensure token is valid before API call
         self._ensure_valid_token()
 
@@ -142,7 +146,9 @@ class CodexClient(LLMClientABC):
                 extra_headers=extra_headers,
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            error_message = f"{e.__class__.__name__} {e!s}"
+            for item in error_stream_items(metadata_tracker, error=error_message):
+                yield item
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):

klaude_code/llm/google/client.py

@@ -5,7 +5,7 @@
 
 import json
 from collections.abc import AsyncGenerator, AsyncIterator
-from typing import Any, cast, override
+from typing import Any, Literal, cast, override
 from uuid import uuid4
 
 import httpx
@@ -26,7 +26,7 @@ from klaude_code.llm.google.input import convert_history_to_contents, convert_to
 from klaude_code.llm.input_common import apply_config_defaults
 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, model
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -114,25 +114,74 @@ def _merge_partial_args(dst: dict[str, Any], partial_args: list[Any] | None) ->
         dst[key] = _partial_arg_value(partial)
 
 
+def _map_finish_reason(reason: str) -> model.StopReason | None:
+    normalized = reason.strip().lower()
+    mapping: dict[str, model.StopReason] = {
+        "stop": "stop",
+        "end_turn": "stop",
+        "max_tokens": "length",
+        "length": "length",
+        "tool_use": "tool_use",
+        "safety": "error",
+        "recitation": "error",
+        "other": "error",
+        "content_filter": "error",
+        "blocked": "error",
+        "blocklist": "error",
+        "cancelled": "aborted",
+        "canceled": "aborted",
+        "aborted": "aborted",
+    }
+    return mapping.get(normalized)
+
+
 async def parse_google_stream(
     stream: AsyncIterator[Any],
     param: llm_param.LLMCallParameter,
     metadata_tracker: MetadataTracker,
-) -> AsyncGenerator[model.ConversationItem]:
+) -> AsyncGenerator[message.LLMStreamItem]:
     response_id: str | None = None
-    started = False
+    stage: Literal["waiting", "thinking", "assistant", "tool"] = "waiting"
 
     accumulated_text: list[str] = []
     accumulated_thoughts: list[str] = []
     thought_signature: str | None = None
+    assistant_parts: list[message.Part] = []
 
     # Track tool calls where args arrive as partial updates.
     partial_args_by_call: dict[str, dict[str, Any]] = {}
     started_tool_calls: dict[str, str] = {}  # call_id -> name
     started_tool_items: set[str] = set()
-    emitted_tool_items: set[str] = set()
+    completed_tool_items: set[str] = set()
 
     last_usage_metadata: UsageMetadata | None = None
+    stop_reason: model.StopReason | None = None
+
+    def flush_thinking() -> None:
+        nonlocal thought_signature
+        if accumulated_thoughts:
+            assistant_parts.append(
+                message.ThinkingTextPart(
+                    text="".join(accumulated_thoughts),
+                    model_id=str(param.model),
+                )
+            )
+            accumulated_thoughts.clear()
+        if thought_signature:
+            assistant_parts.append(
+                message.ThinkingSignaturePart(
+                    signature=thought_signature,
+                    model_id=str(param.model),
+                    format="google_thought_signature",
+                )
+            )
+            thought_signature = None
+
+    def flush_text() -> None:
+        if not accumulated_text:
+            return
+        assistant_parts.append(message.TextPart(text="".join(accumulated_text)))
+        accumulated_text.clear()
 
     async for chunk in stream:
         log_debug(
@@ -143,33 +192,44 @@ async def parse_google_stream(
 
         if response_id is None:
             response_id = getattr(chunk, "response_id", None) or uuid4().hex
-        assert response_id is not None
-        if not started:
-            started = True
-            yield model.StartItem(response_id=response_id)
 
         if getattr(chunk, "usage_metadata", None) is not None:
             last_usage_metadata = chunk.usage_metadata
 
         candidates = getattr(chunk, "candidates", None) or []
         candidate0 = candidates[0] if candidates else None
+        finish_reason = getattr(candidate0, "finish_reason", None) if candidate0 else None
+        if finish_reason is not None:
+            if isinstance(finish_reason, str):
+                reason_value = finish_reason
+            else:
+                reason_value = getattr(finish_reason, "name", None) or str(finish_reason)
+            stop_reason = _map_finish_reason(reason_value)
         content = getattr(candidate0, "content", None) if candidate0 else None
-        parts = getattr(content, "parts", None) if content else None
-        if not parts:
+        content_parts = getattr(content, "parts", None) if content else None
+        if not content_parts:
             continue
 
-        for part in parts:
+        for part in content_parts:
             if getattr(part, "text", None) is not None:
-                metadata_tracker.record_token()
                 text = part.text
+                if not text:
+                    continue
+                metadata_tracker.record_token()
                 if getattr(part, "thought", False) is True:
+                    if stage == "assistant":
+                        flush_text()
+                    stage = "thinking"
                     accumulated_thoughts.append(text)
                     if getattr(part, "thought_signature", None):
                         thought_signature = part.thought_signature
-                    yield model.ReasoningTextDelta(content=text, response_id=response_id)
+                    yield message.ThinkingTextDelta(content=text, response_id=response_id)
                 else:
+                    if stage == "thinking":
+                        flush_thinking()
+                    stage = "assistant"
                     accumulated_text.append(text)
-                    yield model.AssistantMessageDelta(content=text, response_id=response_id)
+                    yield message.AssistantTextDelta(content=text, response_id=response_id)
 
             function_call = getattr(part, "function_call", None)
             if function_call is None:
@@ -182,17 +242,23 @@ async def parse_google_stream(
 
             if call_id not in started_tool_items:
                 started_tool_items.add(call_id)
-                yield model.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
+                yield message.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
 
             args_obj = getattr(function_call, "args", None)
             if args_obj is not None:
-                emitted_tool_items.add(call_id)
-                yield model.ToolCallItem(
-                    response_id=response_id,
-                    call_id=call_id,
-                    name=name,
-                    arguments=json.dumps(args_obj, ensure_ascii=False),
+                if stage == "thinking":
+                    flush_thinking()
+                if stage == "assistant":
+                    flush_text()
+                stage = "tool"
+                assistant_parts.append(
+                    message.ToolCallPart(
+                        call_id=call_id,
+                        tool_name=name,
+                        arguments_json=json.dumps(args_obj, ensure_ascii=False),
+                    )
                 )
+                completed_tool_items.add(call_id)
                 continue
 
             partial_args = getattr(function_call, "partial_args", None)
@@ -201,53 +267,49 @@ async def parse_google_stream(
                 _merge_partial_args(acc, partial_args)
 
             will_continue = getattr(function_call, "will_continue", None)
-            if will_continue is False and call_id in partial_args_by_call and call_id not in emitted_tool_items:
-                emitted_tool_items.add(call_id)
-                yield model.ToolCallItem(
-                    response_id=response_id,
-                    call_id=call_id,
-                    name=name,
-                    arguments=json.dumps(partial_args_by_call[call_id], ensure_ascii=False),
+            if will_continue is False and call_id in partial_args_by_call and call_id not in completed_tool_items:
+                if stage == "thinking":
+                    flush_thinking()
+                if stage == "assistant":
+                    flush_text()
+                stage = "tool"
+                assistant_parts.append(
+                    message.ToolCallPart(
+                        call_id=call_id,
+                        tool_name=name,
+                        arguments_json=json.dumps(partial_args_by_call[call_id], ensure_ascii=False),
+                    )
                 )
+                completed_tool_items.add(call_id)
 
     # Flush any pending tool calls that never produced args.
     for call_id, name in started_tool_calls.items():
-        if call_id in emitted_tool_items:
+        if call_id in completed_tool_items:
             continue
         args = partial_args_by_call.get(call_id, {})
-        emitted_tool_items.add(call_id)
-        yield model.ToolCallItem(
-            response_id=response_id,
-            call_id=call_id,
-            name=name,
-            arguments=json.dumps(args, ensure_ascii=False),
-        )
-
-    if accumulated_thoughts:
-        metadata_tracker.record_token()
-        yield model.ReasoningTextItem(
-            content="".join(accumulated_thoughts),
-            response_id=response_id,
-            model=str(param.model),
-        )
-        if thought_signature:
-            yield model.ReasoningEncryptedItem(
-                encrypted_content=thought_signature,
-                response_id=response_id,
-                model=str(param.model),
-                format="google_thought_signature",
+        assistant_parts.append(
+            message.ToolCallPart(
+                call_id=call_id,
+                tool_name=name,
+                arguments_json=json.dumps(args, ensure_ascii=False),
             )
+        )
 
-    if accumulated_text:
-        metadata_tracker.record_token()
-        yield model.AssistantMessageItem(content="".join(accumulated_text), response_id=response_id)
+    flush_thinking()
+    flush_text()
 
     usage = _usage_from_metadata(last_usage_metadata, context_limit=param.context_limit, max_tokens=param.max_tokens)
     if usage is not None:
         metadata_tracker.set_usage(usage)
     metadata_tracker.set_model_name(str(param.model))
     metadata_tracker.set_response_id(response_id)
-    yield metadata_tracker.finalize()
+    metadata = metadata_tracker.finalize()
+    yield message.AssistantMessage(
+        parts=assistant_parts,
+        response_id=response_id,
+        usage=metadata,
+        stop_reason=stop_reason,
+    )
 
 
 @register(llm_param.LLMClientProtocol.GOOGLE)
@@ -270,7 +332,7 @@ class GoogleClient(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)
 
@@ -297,13 +359,13 @@ class GoogleClient(LLMClientABC):
                 config=config,
             )
         except (APIError, ClientError, ServerError, 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
 
         try:
             async for item in parse_google_stream(stream, param=param, metadata_tracker=metadata_tracker):
                 yield item
         except (APIError, ClientError, ServerError, 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())

klaude_code/llm/google/input.py

@@ -4,89 +4,80 @@
 # pyright: reportAttributeAccessIssue=false
 
 import json
-from base64 import b64decode
-from binascii import Error as BinasciiError
 from typing import Any
 
 from google.genai import types
 
-from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
-from klaude_code.protocol import llm_param, model
+from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.image import parse_data_url
+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 _data_url_to_blob(url: str) -> types.Blob:
-    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")
-
-    media_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
-
+    media_type, _, decoded = parse_data_url(url)
     return types.Blob(data=decoded, mime_type=media_type)
 
 
-def _image_part_to_part(image: model.ImageURLPart) -> types.Part:
-    url = image.image_url.url
+def _image_part_to_part(image: message.ImageURLPart) -> types.Part:
+    url = image.url
     if url.startswith("data:"):
         return types.Part(inline_data=_data_url_to_blob(url))
     # Best-effort: Gemini supports file URIs, and may accept public HTTPS URLs.
     return types.Part(file_data=types.FileData(file_uri=url))
 
 
-def _user_group_to_content(group: UserGroup) -> types.Content:
+def _user_message_to_content(msg: message.UserMessage, attachment: DeveloperAttachment) -> types.Content:
     parts: list[types.Part] = []
-    for text in group.text_parts:
-        parts.append(types.Part(text=text + "\n"))
-    for image in group.images:
+    for part in msg.parts:
+        if isinstance(part, message.TextPart):
+            parts.append(types.Part(text=part.text))
+        elif isinstance(part, message.ImageURLPart):
+            parts.append(_image_part_to_part(part))
+    if attachment.text:
+        parts.append(types.Part(text=attachment.text))
+    for image in attachment.images:
         parts.append(_image_part_to_part(image))
     if not parts:
         parts.append(types.Part(text=""))
     return types.Content(role="user", parts=parts)
 
 
-def _tool_groups_to_content(groups: list[ToolGroup], model_name: str | None) -> list[types.Content]:
+def _tool_messages_to_contents(
+    msgs: list[tuple[message.ToolResultMessage, DeveloperAttachment]], model_name: str | None
+) -> list[types.Content]:
     supports_multimodal_function_response = bool(model_name and "gemini-3" in model_name.lower())
 
     response_parts: list[types.Part] = []
     extra_image_contents: list[types.Content] = []
 
-    for group in groups:
+    for msg, attachment in msgs:
         merged_text = merge_reminder_text(
-            group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
-            group.reminder_texts,
+            msg.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
+            attachment.text,
         )
         has_text = merged_text.strip() != ""
 
-        images = list(group.tool_result.images or []) + list(group.reminder_images)
+        images = [part for part in msg.parts if isinstance(part, message.ImageURLPart)] + attachment.images
         image_parts: list[types.Part] = []
         for image in images:
             try:
                 image_parts.append(_image_part_to_part(image))
             except ValueError:
-                # Skip invalid data URLs
                 continue
 
         has_images = len(image_parts) > 0
         response_value = merged_text if has_text else "(see attached image)" if has_images else ""
-        response_payload = (
-            {"error": response_value} if group.tool_result.status == "error" else {"output": response_value}
-        )
+        response_payload = {"error": response_value} if msg.status != "success" else {"output": response_value}
 
         function_response = types.FunctionResponse(
-            id=group.tool_result.call_id,
-            name=group.tool_result.tool_name or "",
+            id=msg.call_id,
+            name=msg.tool_name,
             response=response_payload,
             parts=image_parts if (has_images and supports_multimodal_function_response) else None,
         )
@@ -104,100 +95,95 @@ def _tool_groups_to_content(groups: list[ToolGroup], model_name: str | None) ->
     return contents
 
 
-def _assistant_group_to_content(group: AssistantGroup, model_name: str | None) -> types.Content | None:
+def _assistant_message_to_content(msg: message.AssistantMessage, model_name: str | None) -> types.Content | None:
     parts: list[types.Part] = []
-
-    degraded_thinking_texts: list[str] = []
+    native_thinking_parts, degraded_thinking_texts = split_thinking_parts(msg, model_name)
+    native_thinking_ids = {id(part) for part in native_thinking_parts}
     pending_thought_text: str | None = None
     pending_thought_signature: str | None = None
 
-    for item in group.reasoning_items:
-        match item:
-            case model.ReasoningTextItem():
-                if not item.content:
-                    continue
-                if model_name is not None and item.model is not None and item.model != model_name:
-                    degraded_thinking_texts.append(item.content)
-                else:
-                    pending_thought_text = item.content
-            case model.ReasoningEncryptedItem():
-                if not (
-                    model_name is not None
-                    and item.model == model_name
-                    and item.encrypted_content
-                    and (item.format or "").startswith("google")
-                    and pending_thought_text
-                ):
-                    continue
-                pending_thought_signature = item.encrypted_content
-                parts.append(
-                    types.Part(
-                        text=pending_thought_text,
-                        thought=True,
-                        thought_signature=pending_thought_signature,
-                    )
-                )
-                pending_thought_text = None
-                pending_thought_signature = None
-
-    if pending_thought_text:
+    def flush_thought() -> None:
+        nonlocal pending_thought_text, pending_thought_signature
+        if pending_thought_text is None and pending_thought_signature is None:
+            return
         parts.append(
             types.Part(
-                text=pending_thought_text,
+                text=pending_thought_text or "",
                 thought=True,
                 thought_signature=pending_thought_signature,
             )
         )
+        pending_thought_text = None
+        pending_thought_signature = None
+
+    for part in msg.parts:
+        if isinstance(part, message.ThinkingTextPart):
+            if id(part) not in native_thinking_ids:
+                continue
+            pending_thought_text = part.text
+            continue
+        if isinstance(part, message.ThinkingSignaturePart):
+            if id(part) not in native_thinking_ids:
+                continue
+            if part.signature and (part.format or "").startswith("google"):
+                pending_thought_signature = part.signature
+            continue
+
+        flush_thought()
+        if isinstance(part, message.TextPart):
+            parts.append(types.Part(text=part.text))
+        elif isinstance(part, message.ToolCallPart):
+            args: dict[str, Any]
+            if part.arguments_json:
+                try:
+                    args = json.loads(part.arguments_json)
+                except json.JSONDecodeError:
+                    args = {"_raw": part.arguments_json}
+            else:
+                args = {}
+            parts.append(types.Part(function_call=types.FunctionCall(id=part.call_id, name=part.tool_name, args=args)))
+
+    flush_thought()
 
     if degraded_thinking_texts:
         parts.insert(0, types.Part(text="<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>"))
 
-    if group.text_content:
-        parts.append(types.Part(text=group.text_content))
-
-    for tc in group.tool_calls:
-        args: dict[str, Any]
-        if tc.arguments:
-            try:
-                args = json.loads(tc.arguments)
-            except json.JSONDecodeError:
-                args = {"_raw": tc.arguments}
-        else:
-            args = {}
-        parts.append(types.Part(function_call=types.FunctionCall(id=tc.call_id, name=tc.name, args=args)))
-
     if not parts:
         return None
     return types.Content(role="model", parts=parts)
 
 
 def convert_history_to_contents(
-    history: list[model.ConversationItem],
+    history: list[message.Message],
     model_name: str | None,
 ) -> list[types.Content]:
     contents: list[types.Content] = []
-    pending_tool_groups: list[ToolGroup] = []
-
-    def flush_tool_groups() -> None:
-        nonlocal pending_tool_groups
-        if pending_tool_groups:
-            contents.extend(_tool_groups_to_content(pending_tool_groups, model_name=model_name))
-            pending_tool_groups = []
-
-    for group in parse_message_groups(history):
-        match group:
-            case UserGroup():
-                flush_tool_groups()
-                contents.append(_user_group_to_content(group))
-            case ToolGroup():
-                pending_tool_groups.append(group)
-            case AssistantGroup():
-                flush_tool_groups()
-                content = _assistant_group_to_content(group, model_name=model_name)
+    pending_tool_messages: list[tuple[message.ToolResultMessage, DeveloperAttachment]] = []
+
+    def flush_tool_messages() -> None:
+        nonlocal pending_tool_messages
+        if pending_tool_messages:
+            contents.extend(_tool_messages_to_contents(pending_tool_messages, model_name=model_name))
+            pending_tool_messages = []
+
+    for msg, attachment in attach_developer_messages(history):
+        match msg:
+            case message.ToolResultMessage():
+                pending_tool_messages.append((msg, attachment))
+            case message.UserMessage():
+                flush_tool_messages()
+                contents.append(_user_message_to_content(msg, attachment))
+            case message.AssistantMessage():
+                flush_tool_messages()
+                content = _assistant_message_to_content(msg, model_name=model_name)
                 if content is not None:
                     contents.append(content)
+            case message.SystemMessage():
+                continue
+            case _:
+                continue
 
-    flush_tool_groups()
+    flush_tool_messages()
     return contents