chore: import upstream snapshot with attribution

python/packages/lab/tau2/tests/test_message_utils.py

@@ -0,0 +1,283 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from unittest.mock import patch
+
+import pytest
+
+try:
+    from litellm import completion as _litellm_completion  # noqa: F401
+except Exception:
+    pytest.skip("LiteLLM import surface required by tau2 is unavailable.", allow_module_level=True)
+
+from agent_framework._types import Content, Message
+from agent_framework_lab_tau2._message_utils import flip_messages, log_messages
+
+
+def test_flip_messages_user_to_assistant():
+    """Test flipping user message to assistant."""
+    messages = [
+        Message(
+            role="user",
+            contents=[Content.from_text(text="Hello assistant")],
+            author_name="User1",
+            message_id="msg_001",
+        )
+    ]
+
+    flipped = flip_messages(messages)
+
+    assert len(flipped) == 1
+    assert flipped[0].role == "assistant"
+    assert flipped[0].text == "Hello assistant"
+    assert flipped[0].author_name == "User1"
+    assert flipped[0].message_id == "msg_001"
+
+
+def test_flip_messages_assistant_to_user():
+    """Test flipping assistant message to user."""
+    messages = [
+        Message(
+            role="assistant",
+            contents=[Content.from_text(text="Hello user")],
+            author_name="Assistant1",
+            message_id="msg_002",
+        )
+    ]
+
+    flipped = flip_messages(messages)
+
+    assert len(flipped) == 1
+    assert flipped[0].role == "user"
+    assert flipped[0].text == "Hello user"
+    assert flipped[0].author_name == "Assistant1"
+    assert flipped[0].message_id == "msg_002"
+
+
+def test_flip_messages_assistant_with_function_calls_filtered():
+    """Test that function calls are filtered out when flipping assistant to user."""
+    function_call = Content.from_function_call(call_id="call_123", name="test_function", arguments={"param": "value"})
+
+    messages = [
+        Message(
+            role="assistant",
+            contents=[
+                Content.from_text(text="I'll call a function"),
+                function_call,
+                Content.from_text(text="After the call"),
+            ],
+            message_id="msg_003",
+        )
+    ]
+
+    flipped = flip_messages(messages)
+
+    assert len(flipped) == 1
+    assert flipped[0].role == "user"
+    # Function call should be filtered out
+    assert len(flipped[0].contents) == 2
+    assert all(content.type == "text" for content in flipped[0].contents)
+    assert "I'll call a function" in flipped[0].text
+    assert "After the call" in flipped[0].text
+
+
+def test_flip_messages_assistant_with_only_function_calls_skipped():
+    """Test that assistant messages with only function calls are skipped."""
+    function_call = Content.from_function_call(call_id="call_456", name="another_function", arguments={"key": "value"})
+
+    messages = [
+        Message(role="assistant", contents=[function_call], message_id="msg_004")  # Only function call, no text
+    ]
+
+    flipped = flip_messages(messages)
+
+    # Should be empty since the message had no text content after filtering
+    assert len(flipped) == 0
+
+
+def test_flip_messages_tool_messages_skipped():
+    """Test that tool messages are skipped."""
+    function_result = Content.from_function_result(call_id="call_789", result={"success": True})
+
+    messages = [Message(role="tool", contents=[function_result])]
+
+    flipped = flip_messages(messages)
+
+    # Tool messages should be skipped
+    assert len(flipped) == 0
+
+
+def test_flip_messages_system_messages_preserved():
+    """Test that system messages are preserved as-is."""
+    messages = [Message(role="system", contents=[Content.from_text(text="System instruction")], message_id="sys_001")]
+
+    flipped = flip_messages(messages)
+
+    assert len(flipped) == 1
+    assert flipped[0].role == "system"
+    assert flipped[0].text == "System instruction"
+    assert flipped[0].message_id == "sys_001"
+
+
+def test_flip_messages_mixed_conversation():
+    """Test flipping a mixed conversation."""
+    function_call = Content.from_function_call(call_id="call_mixed", name="mixed_function", arguments={})
+
+    function_result = Content.from_function_result(call_id="call_mixed", result="function result")
+
+    messages = [
+        Message(role="system", contents=[Content.from_text(text="System prompt")]),
+        Message(role="user", contents=[Content.from_text(text="User question")]),
+        Message(role="assistant", contents=[Content.from_text(text="Assistant response"), function_call]),
+        Message(role="tool", contents=[function_result]),
+        Message(role="assistant", contents=[Content.from_text(text="Final response")]),
+    ]
+
+    flipped = flip_messages(messages)
+
+    # Should have: system (unchanged), assistant (from user), user (from assistant, filtered),
+    # assistant (from final assistant)
+    assert len(flipped) == 4
+
+    # Check each flipped message
+    assert flipped[0].role == "system"
+    assert flipped[0].text == "System prompt"
+
+    assert flipped[1].role == "assistant"
+    assert flipped[1].text == "User question"
+
+    assert flipped[2].role == "user"
+    assert flipped[2].text == "Assistant response"  # Function call filtered out
+
+    # Tool message skipped
+
+    assert flipped[3].role == "user"
+    assert flipped[3].text == "Final response"
+
+
+def test_flip_messages_empty_list():
+    """Test flipping empty message list."""
+    messages: list[Message] = []
+    flipped = flip_messages(messages)
+    assert len(flipped) == 0
+
+
+def test_flip_messages_preserves_metadata():
+    """Test that message metadata is preserved during flipping."""
+    messages = [
+        Message(
+            role="user",
+            contents=[Content.from_text(text="Test message")],
+            author_name="TestUser",
+            message_id="test_123",
+        )
+    ]
+
+    flipped = flip_messages(messages)
+
+    assert len(flipped) == 1
+    assert flipped[0].author_name == "TestUser"
+    assert flipped[0].message_id == "test_123"
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_text_content(mock_logger):
+    """Test logging messages with text content."""
+    messages = [
+        Message(role="user", contents=[Content.from_text(text="Hello")]),
+        Message(role="assistant", contents=[Content.from_text(text="Hi there!")]),
+    ]
+
+    log_messages(messages)
+
+    # Should have called logger.info for each message
+    assert mock_logger.opt.return_value.info.call_count == 2
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_function_call(mock_logger):
+    """Test logging messages with function calls."""
+    function_call = Content.from_function_call(call_id="call_log", name="log_function", arguments={"param": "value"})
+
+    messages = [Message(role="assistant", contents=[function_call])]
+
+    log_messages(messages)
+
+    # Should log the function call
+    mock_logger.opt.return_value.info.assert_called()
+    call_args = mock_logger.opt.return_value.info.call_args[0][0]
+    assert "TOOL_CALL" in call_args
+    assert "log_function" in call_args
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_function_result(mock_logger):
+    """Test logging messages with function results."""
+    function_result = Content.from_function_result(call_id="call_result", result="success")
+
+    messages = [Message(role="tool", contents=[function_result])]
+
+    log_messages(messages)
+
+    # Should log the function result
+    mock_logger.opt.return_value.info.assert_called()
+    call_args = mock_logger.opt.return_value.info.call_args[0][0]
+    assert "TOOL_RESULT" in call_args
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_different_roles(mock_logger):
+    """Test logging messages with different roles get different colors."""
+    messages = [
+        Message(role="system", contents=[Content.from_text(text="System")]),
+        Message(role="user", contents=[Content.from_text(text="User")]),
+        Message(role="assistant", contents=[Content.from_text(text="Assistant")]),
+        Message(role="tool", contents=[Content.from_text(text="Tool")]),
+    ]
+
+    log_messages(messages)
+
+    # Should have called logger for each message
+    assert mock_logger.opt.return_value.info.call_count == 4
+
+    # Check that different color tags are used
+    calls = mock_logger.opt.return_value.info.call_args_list
+    system_call = calls[0][0][0]
+    user_call = calls[1][0][0]
+    assistant_call = calls[2][0][0]
+    tool_call = calls[3][0][0]
+
+    assert "cyan" in system_call or "SYSTEM" in system_call
+    assert "green" in user_call or "USER" in user_call
+    assert "blue" in assistant_call or "ASSISTANT" in assistant_call
+    assert "yellow" in tool_call or "TOOL" in tool_call
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_escapes_html(mock_logger):
+    """Test that HTML-like characters are properly escaped in log output."""
+    messages = [Message(role="user", contents=[Content.from_text(text="Message with <tag> content")])]
+
+    log_messages(messages)
+
+    mock_logger.opt.return_value.info.assert_called()
+    call_args = mock_logger.opt.return_value.info.call_args[0][0]
+    # Should escape < characters
+    assert "\\<tag>" in call_args or "&lt;tag&gt;" in call_args
+
+
+@patch("agent_framework_lab_tau2._message_utils.logger")
+def test_log_messages_mixed_content_types(mock_logger):
+    """Test logging messages with mixed content types."""
+    function_call = Content.from_function_call(call_id="mixed_call", name="mixed_function", arguments={"key": "value"})
+
+    messages = [
+        Message(
+            role="assistant",
+            contents=[Content.from_text(text="I'll call a function"), function_call, Content.from_text(text="Done!")],
+        )
+    ]
+
+    log_messages(messages)
+
+    # Should log multiple times for different content types
+    assert mock_logger.opt.return_value.info.call_count == 3

python/packages/lab/tau2/tests/test_sliding_window.py

@@ -0,0 +1,213 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Tests for sliding window history provider."""
+
+from unittest.mock import patch
+
+import pytest
+
+try:
+    from litellm import completion as _litellm_completion  # noqa: F401
+except Exception:
+    pytest.skip("LiteLLM import surface required by tau2 is unavailable.", allow_module_level=True)
+
+from agent_framework import InMemoryHistoryProvider
+from agent_framework._types import Content, Message
+from agent_framework_lab_tau2._sliding_window import SlidingWindowHistoryProvider
+
+
+def _make_state(provider: SlidingWindowHistoryProvider, messages: list[Message] | None = None) -> dict:
+    """Helper to create a session state dict with messages pre-loaded."""
+    state: dict = {}
+    if messages:
+        state["messages"] = list(messages)
+    return state
+
+
+def test_initialization():
+    """Test initializing with parameters."""
+    provider = SlidingWindowHistoryProvider(
+        max_tokens=2000,
+        system_message="You are a helpful assistant",
+        tool_definitions=[{"name": "test_tool"}],
+    )
+
+    assert provider.max_tokens == 2000
+    assert provider.system_message == "You are a helpful assistant"
+    assert provider.tool_definitions == [{"name": "test_tool"}]
+    assert provider.source_id == InMemoryHistoryProvider.DEFAULT_SOURCE_ID
+
+
+async def test_get_messages_empty():
+    """Test getting messages from empty state."""
+    provider = SlidingWindowHistoryProvider(max_tokens=1000)
+    messages = await provider.get_messages(None, state={})
+    assert messages == []
+
+
+async def test_get_messages_simple():
+    """Test getting messages without truncation."""
+    provider = SlidingWindowHistoryProvider(max_tokens=10000)
+    msgs = [
+        Message(role="user", contents=[Content.from_text(text="What's the weather?")]),
+        Message(role="assistant", contents=[Content.from_text(text="I can help with that.")]),
+    ]
+    state = _make_state(provider, msgs)
+
+    result = await provider.get_messages(None, state=state)
+    assert len(result) == 2
+    assert result[0].text == "What's the weather?"
+    assert result[1].text == "I can help with that."
+
+
+async def test_save_and_get_messages():
+    """Test saving then getting messages with truncation."""
+    provider = SlidingWindowHistoryProvider(max_tokens=50)
+    state: dict = {}
+
+    # Save many messages
+    msgs = [
+        Message(role="user", contents=[Content.from_text(text=f"Message {i} with some content")]) for i in range(10)
+    ]
+    await provider.save_messages(None, msgs, state=state)
+
+    # get_messages returns truncated
+    truncated = await provider.get_messages(None, state=state)
+    # Full history is in session state
+    all_msgs = state["messages"]
+
+    assert len(all_msgs) == 10
+    assert len(truncated) < len(all_msgs)
+
+
+def test_get_token_count_basic():
+    """Test basic token counting."""
+    provider = SlidingWindowHistoryProvider(max_tokens=1000)
+    messages = [Message(role="user", contents=[Content.from_text(text="Hello")])]
+
+    token_count = provider._get_token_count(messages)
+    assert token_count > 0
+
+
+def test_get_token_count_with_system_message():
+    """Test token counting includes system message."""
+    provider = SlidingWindowHistoryProvider(max_tokens=1000, system_message="You are a helpful assistant")
+
+    count_empty = provider._get_token_count([])
+    count_with_msg = provider._get_token_count([Message(role="user", contents=[Content.from_text(text="Hello")])])
+
+    assert count_with_msg > count_empty
+    assert count_empty > 0  # System message contributes tokens
+
+
+def test_get_token_count_function_call():
+    """Test token counting with function calls."""
+    function_call = Content.from_function_call(call_id="call_123", name="test_function", arguments={"param": "value"})
+    provider = SlidingWindowHistoryProvider(max_tokens=1000)
+
+    token_count = provider._get_token_count([Message(role="assistant", contents=[function_call])])
+    assert token_count > 0
+
+
+def test_get_token_count_function_result():
+    """Test token counting with function results."""
+    function_result = Content.from_function_result(call_id="call_123", result={"success": True, "data": "result"})
+    provider = SlidingWindowHistoryProvider(max_tokens=1000)
+
+    token_count = provider._get_token_count([Message(role="tool", contents=[function_result])])
+    assert token_count > 0
+
+
+@patch("agent_framework_lab_tau2._sliding_window.logger")
+def test_truncate_removes_old_messages(mock_logger):
+    """Test that truncation removes old messages when token limit exceeded."""
+    provider = SlidingWindowHistoryProvider(max_tokens=20)
+
+    messages = [
+        Message(
+            role="user",
+            contents=[Content.from_text(text="This is a very long message that should exceed the token limit")],
+        ),
+        Message(
+            role="assistant",
+            contents=[
+                Content.from_text(text="This is another very long message that should also exceed the token limit")
+            ],
+        ),
+        Message(role="user", contents=[Content.from_text(text="Short msg")]),
+    ]
+
+    result = provider._truncate(list(messages))
+    assert len(result) < len(messages)
+    assert mock_logger.warning.called
+
+
+@patch("agent_framework_lab_tau2._sliding_window.logger")
+def test_truncate_removes_leading_tool_messages(mock_logger):
+    """Test that truncation removes leading tool messages."""
+    provider = SlidingWindowHistoryProvider(max_tokens=10000)
+
+    tool_message = Message(role="tool", contents=[Content.from_function_result(call_id="call_123", result="result")])
+    user_message = Message(role="user", contents=[Content.from_text(text="Hello")])
+
+    result = provider._truncate([tool_message, user_message])
+    assert len(result) == 1
+    assert result[0].role == "user"
+    mock_logger.warning.assert_called()
+
+
+def test_estimate_any_object_token_count():
+    """Test token counting for various object types."""
+    provider = SlidingWindowHistoryProvider(max_tokens=1000)
+
+    assert provider._estimate_any_object_token_count({"key": "value"}) > 0
+    assert provider._estimate_any_object_token_count("test string") > 0
+
+    # Non-serializable falls back to str()
+    class Custom:
+        def __str__(self):
+            return "Custom instance"
+
+    assert provider._estimate_any_object_token_count(Custom()) > 0
+
+
+async def test_real_world_scenario():
+    """Test a realistic conversation scenario."""
+    provider = SlidingWindowHistoryProvider(max_tokens=30, system_message="You are a helpful assistant")
+    state: dict = {}
+
+    conversation = [
+        Message(role="user", contents=[Content.from_text(text="Hello, how are you?")]),
+        Message(
+            role="assistant",
+            contents=[Content.from_text(text="I'm doing well, thank you! How can I help you today?")],
+        ),
+        Message(role="user", contents=[Content.from_text(text="Can you tell me about the weather?")]),
+        Message(
+            role="assistant",
+            contents=[
+                Content.from_text(
+                    text="I'd be happy to help with weather information, "
+                    "but I don't have access to current weather data."
+                )
+            ],
+        ),
+        Message(role="user", contents=[Content.from_text(text="What about telling me a joke instead?")]),
+        Message(
+            role="assistant",
+            contents=[
+                Content.from_text(text="Sure! Why don't scientists trust atoms? Because they make up everything!")
+            ],
+        ),
+    ]
+
+    await provider.save_messages(None, conversation, state=state)
+
+    truncated = await provider.get_messages(None, state=state)
+    all_msgs = state["messages"]
+
+    assert len(all_msgs) == 6
+    assert len(truncated) <= 6
+
+    token_count = provider._get_token_count(truncated)
+    assert token_count <= provider.max_tokens * 1.1

python/packages/lab/tau2/tests/test_tau2_utils.py

@@ -0,0 +1,212 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Tests for tau2 utils module."""
+
+import pytest
+
+try:
+    from litellm import completion as _litellm_completion  # noqa: F401
+except Exception:
+    pytest.skip("LiteLLM import surface required by tau2 is unavailable.", allow_module_level=True)
+
+from agent_framework import Content, FunctionTool, Message
+from agent_framework_lab_tau2._tau2_utils import (
+    convert_agent_framework_messages_to_tau2_messages,
+    convert_tau2_tool_to_function_tool,
+)
+from pydantic import BaseModel
+from tau2.data_model.message import AssistantMessage, SystemMessage, ToolCall, ToolMessage, UserMessage
+
+
+class _DummyToolInput(BaseModel):
+    param: str
+
+
+class _DummyToolResult(BaseModel):
+    output: str
+
+
+class _DummyTau2Tool:
+    def __init__(self, name: str, description: str) -> None:
+        self.name = name
+        self._description = description
+        self.params = _DummyToolInput
+
+    def _get_description(self) -> str:
+        return self._description
+
+    def __call__(self, **kwargs: str) -> _DummyToolResult:
+        return _DummyToolResult(output=kwargs["param"])
+
+
+def test_convert_tau2_tool_to_function_tool_basic():
+    """Test basic conversion from tau2 tool to FunctionTool."""
+    tau2_tool = _DummyTau2Tool(name="lookup_booking", description="Lookup booking by id.")
+
+    # Convert the tool
+    tool = convert_tau2_tool_to_function_tool(tau2_tool)  # ty: ignore[invalid-argument-type]  # pyrefly: ignore[bad-argument-type]  # pyright: ignore[reportArgumentType]
+
+    # Verify the conversion
+    assert isinstance(tool, FunctionTool)
+    assert tool.name == tau2_tool.name
+    assert tool.description == tau2_tool._get_description()
+    assert tool.input_model == tau2_tool.params
+
+    assert tool.func is not None
+    result = tool.func(param="ABC123")
+    assert isinstance(result, _DummyToolResult)
+    assert result.output == "ABC123"
+    assert callable(tool.func)
+
+
+def test_convert_tau2_tool_to_function_tool_multiple_tools():
+    """Test conversion with multiple tau2 tools."""
+    tools = [
+        _DummyTau2Tool(name="lookup_booking", description="Lookup booking by id."),
+        _DummyTau2Tool(name="cancel_booking", description="Cancel an existing booking."),
+        _DummyTau2Tool(name="check_policy", description="Get policy details."),
+    ]
+
+    # Convert multiple tools
+    function_tools = [convert_tau2_tool_to_function_tool(tool) for tool in tools]  # ty: ignore[invalid-argument-type]  # pyrefly: ignore[bad-argument-type]  # pyright: ignore[reportArgumentType]
+
+    # Verify all conversions
+    for tool, tau2_tool in zip(function_tools, tools, strict=False):
+        assert isinstance(tool, FunctionTool)
+        assert tool.name == tau2_tool.name
+        assert tool.description == tau2_tool._get_description()
+        assert tool.input_model == tau2_tool.params
+        assert callable(tool.func)
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_system():
+    """Test converting system message."""
+    messages = [Message(role="system", contents=[Content.from_text(text="System instruction")])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], SystemMessage)
+    assert tau2_messages[0].role == "system"
+    assert tau2_messages[0].content == "System instruction"
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_user():
+    """Test converting user message."""
+    messages = [Message(role="user", contents=[Content.from_text(text="Hello assistant")])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], UserMessage)
+    assert tau2_messages[0].role == "user"
+    assert tau2_messages[0].content == "Hello assistant"
+    assert tau2_messages[0].tool_calls is None
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_assistant():
+    """Test converting assistant message."""
+    messages = [Message(role="assistant", contents=[Content.from_text(text="Hello user")])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], AssistantMessage)
+    assert tau2_messages[0].role == "assistant"
+    assert tau2_messages[0].content == "Hello user"
+    assert tau2_messages[0].tool_calls is None
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_with_function_call():
+    """Test converting message with function call."""
+    function_call = Content.from_function_call(call_id="call_123", name="test_function", arguments={"param": "value"})
+
+    messages = [Message(role="assistant", contents=[Content.from_text(text="I'll call a function"), function_call])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], AssistantMessage)
+    assert tau2_messages[0].content == "I'll call a function"
+    assert tau2_messages[0].tool_calls is not None
+    assert len(tau2_messages[0].tool_calls) == 1
+
+    tool_call = tau2_messages[0].tool_calls[0]
+    assert isinstance(tool_call, ToolCall)
+    assert tool_call.id == "call_123"
+    assert tool_call.name == "test_function"
+    assert tool_call.arguments == {"param": "value"}
+    assert tool_call.requestor == "assistant"
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_with_function_result():
+    """Test converting message with function result."""
+    function_result = Content.from_function_result(call_id="call_123", result={"success": True, "data": "result data"})
+
+    messages = [Message(role="tool", contents=[function_result])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], ToolMessage)
+    assert tau2_messages[0].id == "call_123"
+    assert tau2_messages[0].role == "tool"
+    assert tau2_messages[0].content is not None
+    assert '{"success": true, "data": "result data"}' in tau2_messages[0].content
+    assert tau2_messages[0].requestor == "assistant"
+    assert tau2_messages[0].error is False
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_with_error():
+    """Test converting function result with error."""
+    function_result = Content.from_function_result(call_id="call_456", result="Error occurred", exception="Test error")
+
+    messages = [Message(role="tool", contents=[function_result])]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], ToolMessage)
+    assert tau2_messages[0].error is True
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_multiple_text_contents():
+    """Test converting message with multiple text contents."""
+    messages = [
+        Message(role="user", contents=[Content.from_text(text="First part"), Content.from_text(text="Second part")])
+    ]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 1
+    assert isinstance(tau2_messages[0], UserMessage)
+    assert tau2_messages[0].content == "First part Second part"
+
+
+def test_convert_agent_framework_messages_to_tau2_messages_complex_scenario():
+    """Test converting complex scenario with multiple message types."""
+    function_call = Content.from_function_call(call_id="call_789", name="complex_tool", arguments='{"key": "value"}')
+
+    function_result = Content.from_function_result(call_id="call_789", result={"output": "tool result"})
+
+    messages = [
+        Message(role="system", contents=[Content.from_text(text="System prompt")]),
+        Message(role="user", contents=[Content.from_text(text="User request")]),
+        Message(role="assistant", contents=[Content.from_text(text="I'll help you"), function_call]),
+        Message(role="tool", contents=[function_result]),
+        Message(role="assistant", contents=[Content.from_text(text="Based on the result...")]),
+    ]
+
+    tau2_messages = convert_agent_framework_messages_to_tau2_messages(messages)
+
+    assert len(tau2_messages) == 5
+    assert isinstance(tau2_messages[0], SystemMessage)
+    assert isinstance(tau2_messages[1], UserMessage)
+    assert isinstance(tau2_messages[2], AssistantMessage)
+    assert isinstance(tau2_messages[3], ToolMessage)
+    assert isinstance(tau2_messages[4], AssistantMessage)
+
+    # Check the assistant message with tool call
+    assert tau2_messages[2].tool_calls is not None
+    assert len(tau2_messages[2].tool_calls) == 1
+    assert tau2_messages[2].tool_calls[0].name == "complex_tool"