fix(inference, anthropic): emit tool messages before user text in translation

Anthropic only recommends placing tool_result blocks first in a user turn, so a
client may send its text first. The translation flushed that text as a user
message before the tool message, putting a user message between the assistant
tool_calls and its result, which OpenAI rejects. Tool results are now emitted
first regardless of block order, and the rest of the turn follows as a single
user message.

Signed-off-by: LuShadowX <xshadowlu13@gmail.com>

Author: LuShadowX

src/ogx/providers/utils/inference/anthropic_translation.py

@@ -121,52 +121,48 @@ def convert_single_message(msg: AnthropicMessage) -> list[dict[str, Any]]:
         system_text = "\n".join(block.text for block in msg.content if isinstance(block, AnthropicTextBlock))
         return [{"role": "system", "content": system_text}]
 
-    # User message: may contain text and/or tool_result blocks
-    result: list[dict[str, Any]] = []
-    text_parts: list[dict[str, Any]] = []
+    # User message: may contain text and/or tool_result blocks. Anthropic only
+    # recommends putting tool_result blocks first, so they can appear after the
+    # user's own text. OpenAI is stricter: a tool message must follow the
+    # assistant message that requested the call, or another tool message. So the
+    # tool messages are emitted first here whatever order the blocks arrived in,
+    # and the rest of the turn follows as one user message.
+    tool_messages: list[dict[str, Any]] = []
+    content_parts: list[dict[str, Any]] = []
 
     for block in msg.content:
         if isinstance(block, AnthropicToolResultBlock):
-            # Flush accumulated text first
-            if text_parts:
-                if len(text_parts) == 1 and text_parts[0].get("type") == "text":
-                    flush_content: str | list[dict[str, Any]] = text_parts[0]["text"]
-                else:
-                    flush_content = text_parts
-                result.append({"role": "user", "content": flush_content})
-                text_parts = []
-            # Tool results become separate tool messages.
-            # OpenAI tool messages only support text content, so image blocks
-            # from tool results are promoted to a follow-up user message.
             tool_content = block.content
-            image_parts: list[dict[str, Any]] = []
             if isinstance(tool_content, list):
                 text_pieces = []
                 for b in tool_content:
                     if isinstance(b, AnthropicTextBlock):
                         text_pieces.append(b.text)
                     elif isinstance(b, AnthropicImageBlock):
-                        image_parts.append({"type": "image_url", "image_url": {"url": _image_source_to_url(b.source)}})
+                        # OpenAI tool messages only support text content, so image
+                        # blocks from tool results are promoted to the user message.
+                        content_parts.append(
+                            {"type": "image_url", "image_url": {"url": _image_source_to_url(b.source)}}
+                        )
                 tool_content = "\n".join(text_pieces)
-            result.append(
+            tool_messages.append(
                 {
                     "role": "tool",
                     "tool_call_id": block.tool_use_id,
                     "content": tool_content,
                 }
             )
-            if image_parts:
-                result.append({"role": "user", "content": image_parts})
         elif isinstance(block, AnthropicTextBlock):
-            text_parts.append({"type": "text", "text": block.text})
+            content_parts.append({"type": "text", "text": block.text})
         elif isinstance(block, AnthropicImageBlock):
-            text_parts.append({"type": "image_url", "image_url": {"url": _image_source_to_url(block.source)}})
+            content_parts.append({"type": "image_url", "image_url": {"url": _image_source_to_url(block.source)}})
 
-    if text_parts:
-        if len(text_parts) == 1 and text_parts[0].get("type") == "text":
-            user_content: str | list[dict[str, Any]] = text_parts[0]["text"]
+    result: list[dict[str, Any]] = tool_messages
+    if content_parts:
+        if len(content_parts) == 1 and content_parts[0].get("type") == "text":
+            user_content: str | list[dict[str, Any]] = content_parts[0]["text"]
         else:
-            user_content = text_parts
+            user_content = content_parts
         result.append({"role": "user", "content": user_content})
 
     return result if result else [{"role": "user", "content": ""}]

tests/unit/providers/utils/inference/test_anthropic_translation.py

@@ -260,6 +260,68 @@ def test_tool_result_in_user_message(self):
         assert msg["tool_call_id"] == "toolu_123"
         assert msg["content"] == "72F and sunny"
 
+    def test_tool_result_after_text_is_emitted_before_the_user_text(self):
+        """A tool message must follow the assistant message that requested the call.
+
+        Anthropic accepts a user turn whose text precedes its tool_result blocks, but
+        OpenAI rejects a user message sitting between the tool call and its result.
+        """
+        request = AnthropicCreateMessageRequest(
+            model="m",
+            messages=[
+                AnthropicMessage(role="user", content="What is the weather?"),
+                AnthropicMessage(
+                    role="assistant",
+                    content=[AnthropicToolUseBlock(id="toolu_123", name="get_weather", input={"city": "SF"})],
+                ),
+                AnthropicMessage(
+                    role="user",
+                    content=[
+                        AnthropicTextBlock(text="and New York?"),
+                        AnthropicToolResultBlock(tool_use_id="toolu_123", content="72F and sunny"),
+                    ],
+                ),
+            ],
+            max_tokens=100,
+        )
+        result = anthropic_request_to_openai(request)
+
+        roles = [_msg_to_dict(m)["role"] for m in result.messages]
+        assert roles == ["user", "assistant", "tool", "user"]
+        tool_msg = _msg_to_dict(result.messages[2])
+        assert tool_msg["tool_call_id"] == "toolu_123"
+        assert tool_msg["content"] == "72F and sunny"
+        assert _msg_to_dict(result.messages[3])["content"] == "and New York?"
+
+    def test_tool_results_split_by_text_stay_adjacent(self):
+        request = AnthropicCreateMessageRequest(
+            model="m",
+            messages=[
+                AnthropicMessage(
+                    role="assistant",
+                    content=[
+                        AnthropicToolUseBlock(id="toolu_1", name="a", input={}),
+                        AnthropicToolUseBlock(id="toolu_2", name="b", input={}),
+                    ],
+                ),
+                AnthropicMessage(
+                    role="user",
+                    content=[
+                        AnthropicToolResultBlock(tool_use_id="toolu_1", content="first"),
+                        AnthropicTextBlock(text="between"),
+                        AnthropicToolResultBlock(tool_use_id="toolu_2", content="second"),
+                    ],
+                ),
+            ],
+            max_tokens=100,
+        )
+        result = anthropic_request_to_openai(request)
+
+        roles = [_msg_to_dict(m)["role"] for m in result.messages]
+        assert roles == ["assistant", "tool", "tool", "user"]
+        assert [_msg_to_dict(m)["tool_call_id"] for m in result.messages[1:3]] == ["toolu_1", "toolu_2"]
+        assert _msg_to_dict(result.messages[3])["content"] == "between"
+
     def test_base64_image_in_user_message(self):
         request = AnthropicCreateMessageRequest(
             model="m",