Skip to content

Build and run agents you can see, understand and trust.

35.8 KB
Raw Blame
# -*- coding: utf-8 -*-
"""Comprehensive formatter unit tests for OpenAIResponseFormatter and
OpenAIResponseMultiAgentFormatter, following the reference test style with
exact ground-truth comparisons.

Key differences from OpenAI Chat formatter:
  - Text content type is "input_text" (not "text").
  - Image content type is "input_image" with flat "image_url" string.
  - Tool calls become top-level "function_call" items (not nested in a msg).
  - Tool results become top-level "function_call_output" items.
  - ThinkingBlock: only echoed when it has a "reasoning_item_id" attribute.
"""
from unittest import IsolatedAsyncioTestCase

from agentscope.formatter import (
    OpenAIResponseFormatter,
    OpenAIResponseMultiAgentFormatter,
)
from agentscope.message import (
    UserMsg,
    AssistantMsg,
    SystemMsg,
    TextBlock,
    DataBlock,
    ToolCallBlock,
    ToolResultBlock,
    ToolResultState,
    Base64Source,
    URLSource,
    ThinkingBlock,
    HintBlock,
)


class TestOpenAIResponseFormatter(IsolatedAsyncioTestCase):
    """Comprehensive tests for OpenAI Responses API formatters."""

    async def asyncSetUp(self) -> None:
        """Set up shared message fixtures and expected ground-truth dicts."""
        _img_src = URLSource(
            url="https://example.com/image.png",
            media_type="image/png",
        )
        self.image_url = str(_img_src.url)

        self.image_b64 = "ZmFrZSBpbWFnZSBkYXRh"
        self.image_data_uri = f"data:image/png;base64,{self.image_b64}"

        # ---------------------------------------------------------------
        # Message fixtures (no audio to avoid downloads)
        # ---------------------------------------------------------------
        self.msgs_system = [
            SystemMsg(
                name="system",
                content="You're a helpful assistant.",
            ),
        ]

        self.msgs_conversation = [
            UserMsg(
                name="user",
                content=[
                    TextBlock(text="What is the capital of France?"),
                    DataBlock(
                        source=URLSource(
                            url=self.image_url,
                            media_type="image/png",
                        ),
                    ),
                ],
            ),
            AssistantMsg(
                name="assistant",
                content="The capital of France is Paris.",
            ),
            UserMsg(
                name="user",
                content="What is the capital of Germany?",
            ),
            AssistantMsg(
                name="assistant",
                content="The capital of Germany is Berlin.",
            ),
            UserMsg(
                name="user",
                content="What is the capital of Japan?",
            ),
        ]

        self.msgs_tools = [
            AssistantMsg(
                name="assistant",
                content=[
                    ToolCallBlock(
                        id="call_1",
                        name="get_capital",
                        input='{"country": "Japan"}',
                    ),
                    ToolResultBlock(
                        id="call_1",
                        name="get_capital",
                        output=[
                            TextBlock(text="The capital of Japan is Tokyo."),
                        ],
                        state=ToolResultState.SUCCESS,
                    ),
                    TextBlock(text="The capital of Japan is Tokyo."),
                ],
            ),
        ]

        # ---------------------------------------------------------------
        # Ground truth: OpenAIResponseFormatter
        #   - Text: {"type": "input_text", "text": ...}
        #   - Image: {"type": "input_image", "image_url": url_string}
        #   - ToolCallBlock → top-level {"type": "function_call", ...} item
        #   - ToolResultBlock → top-level {"type": "function_call_output", ...}
        #   - No "name" field on messages.
        # ---------------------------------------------------------------
        self.gt_chat = [
            {
                "role": "system",
                "content": [
                    {
                        "type": "input_text",
                        "text": "You're a helpful assistant.",
                    },
                ],
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "What is the capital of France?",
                    },
                    {"type": "input_image", "image_url": self.image_url},
                ],
            },
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "output_text",
                        "text": "The capital of France is Paris.",
                    },
                ],
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "What is the capital of Germany?",
                    },
                ],
            },
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "output_text",
                        "text": "The capital of Germany is Berlin.",
                    },
                ],
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "What is the capital of Japan?",
                    },
                ],
            },
            {
                "type": "function_call",
                "call_id": "call_1",
                "name": "get_capital",
                "arguments": '{"country": "Japan"}',
            },
            {
                "type": "function_call_output",
                "call_id": "call_1",
                "output": "The capital of Japan is Tokyo.",
            },
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "output_text",
                        "text": "The capital of Japan is Tokyo.",
                    },
                ],
            },
        ]

        # ---------------------------------------------------------------
        # Ground truth: OpenAIResponseMultiAgentFormatter
        #   - System: {"role": "system", "content": plain_string}
        #   - Conversation history: input_text with history wrapping.
        #   - Tool sequences use OpenAIResponseFormatter (function_call /
        #     function_call_output top-level items).
        # ---------------------------------------------------------------
        _hist_prompt = (
            OpenAIResponseMultiAgentFormatter().conversation_history_prompt
        )

        _conv_text = (
            "user: What is the capital of France?\n"
            "assistant: The capital of France is Paris.\n"
            "user: What is the capital of Germany?\n"
            "assistant: The capital of Germany is Berlin.\n"
            "user: What is the capital of Japan?"
        )

        self._gt_trailing_asst = {
            "role": "assistant",
            "content": [
                {
                    "type": "output_text",
                    "text": "The capital of Japan is Tokyo.",
                },
            ],
        }

        self._gt_tool_call = {
            "type": "function_call",
            "call_id": "call_1",
            "name": "get_capital",
            "arguments": '{"country": "Japan"}',
        }
        self._gt_tool_result = {
            "type": "function_call_output",
            "call_id": "call_1",
            "output": "The capital of Japan is Tokyo.",
        }

        self.gt_multiagent = [
            {
                "role": "system",
                "content": "You're a helpful assistant.",
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": (
                            _hist_prompt
                            + "<history>\n"
                            + _conv_text
                            + "\n</history>"
                        ),
                    },
                    {"type": "input_image", "image_url": self.image_url},
                ],
            },
            self._gt_tool_call,
            self._gt_tool_result,
            self._gt_trailing_asst,
        ]

    # -------------------------------------------------------------------
    # OpenAIResponseFormatter tests
    # -------------------------------------------------------------------

    async def test_chat_formatter(self) -> None:
        """Chat formatter produces exact output for various subsets."""
        fmt = OpenAIResponseFormatter()

        # Full history
        res = await fmt.format(
            [*self.msgs_system, *self.msgs_conversation, *self.msgs_tools],
        )
        self.assertListEqual(self.gt_chat, res)

        # Without system
        res = await fmt.format([*self.msgs_conversation, *self.msgs_tools])
        self.assertListEqual(self.gt_chat[1:], res)

        # Without conversation
        n_tools_gt = len(self.gt_chat) - 1 - len(self.msgs_conversation)
        res = await fmt.format([*self.msgs_system, *self.msgs_tools])
        self.assertListEqual(
            [self.gt_chat[0]] + self.gt_chat[-n_tools_gt:],
            res,
        )

        # Without tools
        res = await fmt.format([*self.msgs_system, *self.msgs_conversation])
        self.assertListEqual(self.gt_chat[:-n_tools_gt], res)

        # Empty
        res = await fmt.format([])
        self.assertListEqual([], res)

    async def test_chat_formatter_base64_image(self) -> None:
        """Base64-encoded image becomes an input_image item with data URI."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            UserMsg(
                name="user",
                content=[
                    TextBlock(text="What's in this image?"),
                    DataBlock(
                        source=Base64Source(
                            data=self.image_b64,
                            media_type="image/png",
                        ),
                    ),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "What's in this image?",
                        },
                        {
                            "type": "input_image",
                            "image_url": self.image_data_uri,
                        },
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_image_detail_extra_param(self) -> None:
        """Responses API forwards image detail at input_image top level."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            UserMsg(
                name="user",
                content=[
                    TextBlock(text="Inspect this image."),
                    DataBlock(
                        source=URLSource(
                            url=self.image_url,
                            media_type="image/png",
                        ),
                        detail="high",
                        custom_param="value",
                    ),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "Inspect this image.",
                        },
                        {
                            "type": "input_image",
                            "image_url": self.image_url,
                            "detail": "high",
                            "custom_param": "value",
                        },
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_base64_pdf(self) -> None:
        """Base64-encoded PDF becomes an ``input_file`` item."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            UserMsg(
                name="user",
                content=[
                    TextBlock(text="Summarize this."),
                    DataBlock(
                        source=Base64Source(
                            data="JVBERi0xLjQgZmFrZQ==",
                            media_type="application/pdf",
                        ),
                    ),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "user",
                    "content": [
                        {"type": "input_text", "text": "Summarize this."},
                        {
                            "type": "input_file",
                            "filename": "document.pdf",
                            "file_data": "data:application/pdf;"
                            "base64,JVBERi0xLjQgZmFrZQ==",
                        },
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_thinking_dropped_without_reasoning_item_id(
        self,
    ) -> None:
        """ThinkingBlock without reasoning_item_id is silently skipped."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    ThinkingBlock(thinking="inner thoughts"),
                    TextBlock(text="reply"),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "reply"},
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_thinking_echoed_with_reasoning_item_id(
        self,
    ) -> None:
        """ThinkingBlock with reasoning_item_id is echoed as a reasoning
        item."""
        fmt = OpenAIResponseFormatter()
        thinking = ThinkingBlock(thinking="my reasoning")
        thinking.reasoning_item_id = "rs_001"
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[thinking, TextBlock(text="reply")],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "type": "reasoning",
                    "id": "rs_001",
                    "summary": [
                        {"type": "summary_text", "text": "my reasoning"},
                    ],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "reply"},
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_replays_raw_reasoning_item(self) -> None:
        """Split thinking blocks replay one complete item before tool calls."""
        reasoning_item_raw = {
            "type": "reasoning",
            "id": "rs_encrypted",
            "summary": [
                {"type": "summary_text", "text": "summary"},
            ],
            "content": [
                {"type": "reasoning_text", "text": "reasoning"},
            ],
            "encrypted_content": "encrypted_payload",
            "status": "completed",
        }
        thinking = ThinkingBlock(
            thinking="summary",
            reasoning_item_id="rs_encrypted",
            reasoning_item_raw=reasoning_item_raw,
        )
        fmt = OpenAIResponseFormatter()

        res = await fmt.format(
            [
                AssistantMsg(
                    name="assistant",
                    content=[
                        thinking,
                        TextBlock(text="reply"),
                        thinking.model_copy(
                            update={
                                "id": "raw-block",
                                "thinking": "reasoning",
                            },
                        ),
                        ToolCallBlock(id="call_1", name="lookup", input="{}"),
                        ToolResultBlock(
                            id="call_1",
                            name="lookup",
                            output=[TextBlock(text="result")],
                            state=ToolResultState.SUCCESS,
                        ),
                    ],
                ),
            ],
        )

        self.assertListEqual(
            res,
            [
                reasoning_item_raw,
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "reply"},
                    ],
                },
                {
                    "type": "function_call",
                    "call_id": "call_1",
                    "name": "lookup",
                    "arguments": "{}",
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_1",
                    "output": "result",
                },
            ],
        )
        self.assertIsNot(res[0], reasoning_item_raw)
        self.assertIsNot(res[0]["summary"], reasoning_item_raw["summary"])
        self.assertIsNot(res[0]["content"], reasoning_item_raw["content"])

    async def test_chat_formatter_invalid_raw_reasoning_uses_fallback(
        self,
    ) -> None:
        """Malformed raw items cannot bypass the reconstructed fallback."""
        fmt = OpenAIResponseFormatter()
        invalid_raw_items = [
            None,
            [],
            {
                "type": "message",
                "id": "rs_expected",
            },
            {
                "type": "reasoning",
                "id": "rs_other",
                "summary": [],
            },
        ]

        for reasoning_item_raw in invalid_raw_items:
            with self.subTest(reasoning_item_raw=reasoning_item_raw):
                thinking = ThinkingBlock(
                    thinking="summary",
                    reasoning_item_id="rs_expected",
                    reasoning_item_raw=reasoning_item_raw,
                )
                res = await fmt.format(
                    [AssistantMsg(name="assistant", content=[thinking])],
                )
                self.assertListEqual(
                    res,
                    [
                        {
                            "type": "reasoning",
                            "id": "rs_expected",
                            "summary": [
                                {
                                    "type": "summary_text",
                                    "text": "summary",
                                },
                            ],
                            "content": [],
                        },
                    ],
                )

    async def test_chat_formatter_empty_thinking_echoed_with_reasoning_item_id(
        self,
    ) -> None:
        """Empty ThinkingBlock with reasoning_item_id is echoed first."""
        fmt = OpenAIResponseFormatter()
        thinking = ThinkingBlock(thinking="")
        thinking.reasoning_item_id = "rs_empty"
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[TextBlock(text="reply"), thinking],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "type": "reasoning",
                    "id": "rs_empty",
                    "summary": [],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "reply"},
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_reasoning_not_globally_sorted(
        self,
    ) -> None:
        """Reasoning replay keeps existing tool/result boundaries."""
        fmt = OpenAIResponseFormatter()
        thinking_1 = ThinkingBlock(thinking="thinking_1")
        thinking_1.reasoning_item_id = "rs_1"
        thinking_2 = ThinkingBlock(thinking="thinking_2")
        thinking_2.reasoning_item_id = "rs_2"
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    thinking_1,
                    TextBlock(text="text_1"),
                    ToolCallBlock(
                        id="call_1",
                        name="func_1",
                        input='{"arg": "value1"}',
                    ),
                    ToolResultBlock(
                        id="call_1",
                        name="func_1",
                        output=[TextBlock(text="result_1")],
                        state=ToolResultState.SUCCESS,
                    ),
                    thinking_2,
                    TextBlock(text="text_2"),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "type": "reasoning",
                    "id": "rs_1",
                    "summary": [
                        {"type": "summary_text", "text": "thinking_1"},
                    ],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_1"},
                    ],
                },
                {
                    "type": "function_call",
                    "call_id": "call_1",
                    "name": "func_1",
                    "arguments": '{"arg": "value1"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_1",
                    "output": "result_1",
                },
                {
                    "type": "reasoning",
                    "id": "rs_2",
                    "summary": [
                        {"type": "summary_text", "text": "thinking_2"},
                    ],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_2"},
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_reasoning_splits_text_segments(
        self,
    ) -> None:
        """Non-empty reasoning starts a new assistant text segment."""
        fmt = OpenAIResponseFormatter()
        thinking_1 = ThinkingBlock(thinking="thinking_1")
        thinking_1.reasoning_item_id = "rs_1"
        thinking_2 = ThinkingBlock(thinking="thinking_2")
        thinking_2.reasoning_item_id = "rs_2"
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    thinking_1,
                    TextBlock(text="text_1"),
                    thinking_2,
                    TextBlock(text="text_2"),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "type": "reasoning",
                    "id": "rs_1",
                    "summary": [
                        {"type": "summary_text", "text": "thinking_1"},
                    ],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_1"},
                    ],
                },
                {
                    "type": "reasoning",
                    "id": "rs_2",
                    "summary": [
                        {"type": "summary_text", "text": "thinking_2"},
                    ],
                    "content": [],
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_2"},
                    ],
                },
            ],
            res,
        )

    # -------------------------------------------------------------------
    # OpenAIResponseMultiAgentFormatter tests
    # -------------------------------------------------------------------

    async def test_multiagent_formatter(self) -> None:
        """MultiAgent formatter produces exact output for various subsets."""
        fmt = OpenAIResponseMultiAgentFormatter()

        # Full history
        res = await fmt.format(
            [*self.msgs_system, *self.msgs_conversation, *self.msgs_tools],
        )
        self.assertListEqual(self.gt_multiagent, res)

        # Without system
        res = await fmt.format([*self.msgs_conversation, *self.msgs_tools])
        self.assertListEqual(self.gt_multiagent[1:], res)

        # Without tools
        res = await fmt.format([*self.msgs_system, *self.msgs_conversation])
        self.assertListEqual(self.gt_multiagent[:2], res)

        # System only
        res = await fmt.format(self.msgs_system)
        self.assertListEqual([self.gt_multiagent[0]], res)

        # Conversation only
        res = await fmt.format(self.msgs_conversation)
        self.assertListEqual([self.gt_multiagent[1]], res)

        # Tools only
        res = await fmt.format(self.msgs_tools)
        self.assertListEqual(
            [
                self._gt_tool_call,
                self._gt_tool_result,
                self._gt_trailing_asst,
            ],
            res,
        )

        # System + tools
        res = await fmt.format([*self.msgs_system, *self.msgs_tools])
        self.assertListEqual(
            [
                self.gt_multiagent[0],
                self._gt_tool_call,
                self._gt_tool_result,
                self._gt_trailing_asst,
            ],
            res,
        )

        # Empty
        res = await fmt.format([])
        self.assertListEqual([], res)

    async def test_chat_formatter_complex_multi_step(self) -> None:
        """Complex multi-step sequence with interleaved thinking, text,
        tool calls, and tool results."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    ThinkingBlock(thinking="thinking_1"),
                    TextBlock(text="text_1"),
                    ToolCallBlock(
                        id="call_1",
                        name="func_1",
                        input='{"arg": "value1"}',
                    ),
                    ToolCallBlock(
                        id="call_2",
                        name="func_2",
                        input='{"arg": "value2"}',
                    ),
                    ToolResultBlock(
                        id="call_1",
                        name="func_1",
                        output=[
                            TextBlock(text="result_1"),
                            DataBlock(
                                source=Base64Source(
                                    data=self.image_b64,
                                    media_type="image/png",
                                ),
                            ),
                        ],
                        state=ToolResultState.SUCCESS,
                    ),
                    ToolResultBlock(
                        id="call_2",
                        name="func_2",
                        output=[TextBlock(text="result_2")],
                        state=ToolResultState.SUCCESS,
                    ),
                    ThinkingBlock(thinking="thinking_2"),
                    TextBlock(text="text_2"),
                    ToolCallBlock(
                        id="call_3",
                        name="func_3",
                        input='{"arg": "value3"}',
                    ),
                    ToolResultBlock(
                        id="call_3",
                        name="func_3",
                        output=[TextBlock(text="result_3")],
                        state=ToolResultState.SUCCESS,
                    ),
                    ToolCallBlock(
                        id="call_4",
                        name="func_4",
                        input='{"arg": "value4"}',
                    ),
                    ToolResultBlock(
                        id="call_4",
                        name="func_4",
                        output=[TextBlock(text="result_4")],
                        state=ToolResultState.SUCCESS,
                    ),
                    ThinkingBlock(thinking="thinking_3"),
                    TextBlock(text="text_3"),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_1"},
                    ],
                },
                {
                    "type": "function_call",
                    "call_id": "call_1",
                    "name": "func_1",
                    "arguments": '{"arg": "value1"}',
                },
                {
                    "type": "function_call",
                    "call_id": "call_2",
                    "name": "func_2",
                    "arguments": '{"arg": "value2"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_1",
                    "output": [
                        {"type": "input_text", "text": "result_1"},
                        {
                            "type": "input_image",
                            "image_url": self.image_data_uri,
                        },
                    ],
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_2",
                    "output": "result_2",
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_2"},
                    ],
                },
                {
                    "type": "function_call",
                    "call_id": "call_3",
                    "name": "func_3",
                    "arguments": '{"arg": "value3"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_3",
                    "output": "result_3",
                },
                {
                    "type": "function_call",
                    "call_id": "call_4",
                    "name": "func_4",
                    "arguments": '{"arg": "value4"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call_4",
                    "output": "result_4",
                },
                {
                    "role": "assistant",
                    "content": [
                        {"type": "output_text", "text": "text_3"},
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_hint_block(self) -> None:
        """HintBlock flushes preceding content and becomes a user message."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    TextBlock(text="Let me think about that."),
                    HintBlock(hint="Remember to be concise."),
                    TextBlock(text="Here is my answer."),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "output_text",
                            "text": "Let me think about that.",
                        },
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "Remember to be concise.",
                        },
                    ],
                },
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "output_text",
                            "text": "Here is my answer.",
                        },
                    ],
                },
            ],
            res,
        )

    async def test_chat_formatter_hint_block_multimodal(self) -> None:
        """Multimodal HintBlock becomes a single user message with text +
        image."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    HintBlock(
                        hint=[
                            TextBlock(text="Inspect this screenshot:"),
                            DataBlock(
                                source=Base64Source(
                                    data=self.image_b64,
                                    media_type="image/png",
                                ),
                            ),
                        ],
                    ),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "Inspect this screenshot:",
                        },
                        {
                            "type": "input_image",
                            "image_url": self.image_data_uri,
                        },
                    ],
                },
            ],
            res,
        )

    async def test_tool_call_id_used_as_call_id(self) -> None:
        """The formatter uses ToolCallBlock.id as function_call.call_id
        and ToolResultBlock.id as function_call_output.call_id."""
        fmt = OpenAIResponseFormatter()
        msgs = [
            AssistantMsg(
                name="assistant",
                content=[
                    ToolCallBlock(
                        id="call-1",
                        name="search",
                        input='{"q": "test"}',
                    ),
                    ToolResultBlock(
                        id="call-1",
                        name="search",
                        output=[TextBlock(text="result")],
                        state=ToolResultState.SUCCESS,
                    ),
                ],
            ),
        ]
        res = await fmt.format(msgs)
        self.assertListEqual(
            [
                {
                    "type": "function_call",
                    "call_id": "call-1",
                    "name": "search",
                    "arguments": '{"q": "test"}',
                },
                {
                    "type": "function_call_output",
                    "call_id": "call-1",
                    "output": "result",
                },
            ],
            res,
        )