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

# What does this PR do?

`convert_single_message` flushed a user turn's accumulated text as a
`user` message as soon as it hit a `tool_result` block. When a client
puts its text before the tool result, that lands a `user` message
between the assistant `tool_calls` message and the tool result:

```text
assistant  tool_calls=[toolu_123]
user       "and New York?"
tool       tool_call_id=toolu_123
```

OpenAI rejects that ordering — `Invalid parameter: messages with role
'tool' must be a response to a preceding message with 'tool_calls'` — so
every such request fails once translated, and the caller sees a provider
error rather than an answer.

Anthropic only *recommends* placing `tool_result` blocks first in the
user turn; it accepts them after text, and
`AnthropicCreateMessageRequest` accepts them too. Two `tool_result`
blocks separated by text were worse still: they came out as `tool, user,
tool`.

Tool messages are now emitted first whatever order the blocks arrived
in, and the remainder of the turn follows as a single `user` message.
Text blocks keep their relative order, and images promoted out of
`tool_result` content still land in that trailing user message.

Only the ordering changes. A turn that carries just `tool_result`
blocks, or just text, is untouched.

## Test Plan

Two cases added to
`tests/unit/providers/utils/inference/test_anthropic_translation.py`.
Both fail on `main` and pass here:

```console
$ uv run pytest tests/unit/providers/utils/inference/test_anthropic_translation.py -q
51 passed in 0.09s

# on main, with the two new cases applied:
2 failed, 49 passed in 0.12s
FAILED ...::test_tool_result_after_text_is_emitted_before_the_user_text
FAILED ...::test_tool_results_split_by_text_stay_adjacent
```

Script, `demo.py`:

```python
from ogx.providers.utils.inference.anthropic_translation import anthropic_request_to_openai
from ogx_api.messages.models import (
    AnthropicCreateMessageRequest,
    AnthropicMessage,
    AnthropicTextBlock,
    AnthropicToolResultBlock,
    AnthropicToolUseBlock,
)

request = AnthropicCreateMessageRequest(
    model="m",
    max_tokens=100,
    messages=[
        AnthropicMessage(role="user", content="What is the weather in SF?"),
        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"),
            ],
        ),
    ],
)

messages = [m.model_dump(exclude_none=True) for m in anthropic_request_to_openai(request).messages]
for i, m in enumerate(messages):
    extra = f" tool_call_id={m['tool_call_id']}" if m.get("tool_call_id") else ""
    extra += " tool_calls=yes" if m.get("tool_calls") else ""
    print(f"{i}: role={m['role']}{extra} content={str(m.get('content'))[:40]!r}")

previous = None
for m in messages:
    if m["role"] == "tool":
        ok = previous is not None and (
            previous["role"] == "tool" or (previous["role"] == "assistant" and previous.get("tool_calls"))
        )
        if not ok:
            raise SystemExit(f"\nINVALID: tool message preceded by role={previous['role'] if previous else None}")
    previous = m
print("\nVALID: every tool message follows the assistant tool_calls message or another tool message")
```

On `main`:

```console
$ uv run python demo.py
0: role=user content='What is the weather in SF?'
1: role=assistant tool_calls=yes content='None'
2: role=user content='and New York?'
3: role=tool tool_call_id=toolu_123 content='72F and sunny'

INVALID: tool message preceded by role=user
```

On this branch:

```console
$ uv run python demo.py
0: role=user content='What is the weather in SF?'
1: role=assistant tool_calls=yes content='None'
2: role=tool tool_call_id=toolu_123 content='72F and sunny'
3: role=user content='and New York?'

VALID: every tool message follows the assistant tool_calls message or another tool message
```

Full unit suite, unchanged apart from the two new cases:

```console
$ uv run pytest tests/unit/ -q
1 failed, 3260 passed, 5 skipped, 3 xfailed, 61 errors      # this branch
1 failed, 3258 passed, 5 skipped, 3 xfailed, 61 errors      # main
```

The one failure and the 61 errors are `tests/unit/providers/vector_io/`
on both sides — `_create_sqlite_connection` cannot load `sqlite_vec` on
this macOS box. Not related to this change.

`ruff check`, `ruff format --check` and `mypy` are clean on both files,
and `pre-commit run --files <both files>` passes every hook.

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",