Skip to content

A programming framework for agentic AI

Fix output task messages 6150 (#6678)

Tejas Dharanif650d35faa3f
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index 6f9c06742..ea4a74a28 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -113,6 +113,7 @@ class BaseChatAgent(ChatAgent, ABC, ComponentBase[BaseModel]):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> TaskResult:
"""Run the agent with the given task and return the result."""
with trace_invoke_agent_span(
@@ -128,10 +129,12 @@ class BaseChatAgent(ChatAgent, ABC, ComponentBase[BaseModel]):
elif isinstance(task, str):
text_msg = TextMessage(content=task, source="user")
input_messages.append(text_msg)
- output_messages.append(text_msg)
+ if output_task_messages:
+ output_messages.append(text_msg)
elif isinstance(task, BaseChatMessage):
input_messages.append(task)
- output_messages.append(task)
+ if output_task_messages:
+ output_messages.append(task)
else:
if not task:
raise ValueError("Task list cannot be empty.")
@@ -139,7 +142,8 @@ class BaseChatAgent(ChatAgent, ABC, ComponentBase[BaseModel]):
for msg in task:
if isinstance(msg, BaseChatMessage):
input_messages.append(msg)
- output_messages.append(msg)
+ if output_task_messages:
+ output_messages.append(msg)
else:
raise ValueError(f"Invalid message type in sequence: {type(msg)}")
response = await self.on_messages(input_messages, cancellation_token)
@@ -153,9 +157,16 @@ class BaseChatAgent(ChatAgent, ABC, ComponentBase[BaseModel]):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> AsyncGenerator[BaseAgentEvent | BaseChatMessage | TaskResult, None]:
"""Run the agent with the given task and return a stream of messages
- and the final task result as the last item in the stream."""
+ and the final task result as the last item in the stream.
+
+ Args:
+ task: The task to run. Can be a string, a single message, or a sequence of messages.
+ cancellation_token: The cancellation token to kill the task immediately.
+ output_task_messages: Whether to include task messages in the output stream. Defaults to True for backward compatibility.
+ """
with trace_invoke_agent_span(
agent_name=self.name,
agent_description=self.description,
@@ -169,20 +180,23 @@ class BaseChatAgent(ChatAgent, ABC, ComponentBase[BaseModel]):
elif isinstance(task, str):
text_msg = TextMessage(content=task, source="user")
input_messages.append(text_msg)
- output_messages.append(text_msg)
- yield text_msg
+ if output_task_messages:
+ output_messages.append(text_msg)
+ yield text_msg
elif isinstance(task, BaseChatMessage):
input_messages.append(task)
- output_messages.append(task)
- yield task
+ if output_task_messages:
+ output_messages.append(task)
+ yield task
else:
if not task:
raise ValueError("Task list cannot be empty.")
for msg in task:
if isinstance(msg, BaseChatMessage):
input_messages.append(msg)
- output_messages.append(msg)
- yield msg
+ if output_task_messages:
+ output_messages.append(msg)
+ yield msg
else:
raise ValueError(f"Invalid message type in sequence: {type(msg)}")
async for message in self.on_messages_stream(input_messages, cancellation_token):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
index 9ed960636..31f26db65 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
@@ -175,7 +175,6 @@ class SocietyOfMindAgent(BaseChatAgent, Component[SocietyOfMindAgentConfig]):
result: TaskResult | None = None
inner_messages: List[BaseAgentEvent | BaseChatMessage] = []
model_context = self._model_context
- count = 0
prev_content = await model_context.get_messages()
if len(prev_content) > 0:
@@ -192,14 +191,13 @@ class SocietyOfMindAgent(BaseChatAgent, Component[SocietyOfMindAgentConfig]):
else:
task = task_messages
- async for inner_msg in self._team.run_stream(task=task, cancellation_token=cancellation_token):
+ # Use the new output_task_messages parameter to avoid fragile count-based logic
+ async for inner_msg in self._team.run_stream(
+ task=task, cancellation_token=cancellation_token, output_task_messages=False
+ ):
if isinstance(inner_msg, TaskResult):
result = inner_msg
else:
- count += 1
- if count <= len(task_messages):
- # Skip the task messages.
- continue
yield inner_msg
if isinstance(inner_msg, ModelClientStreamingChunkEvent):
# Skip the model client streaming chunk events.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 747535c90..d585be1db 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -24,6 +24,7 @@ class TaskRunner(Protocol):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> TaskResult:
"""Run the task and return the result.
@@ -31,7 +32,13 @@ class TaskRunner(Protocol):
The runner is stateful and a subsequent call to this method will continue
from where the previous call left off. If the task is not specified,
- the runner will continue with the current task."""
+ the runner will continue with the current task.
+
+ Args:
+ task: The task to run. Can be a string, a single message, or a sequence of messages.
+ cancellation_token: The cancellation token to kill the task immediately.
+ output_task_messages: Whether to include task messages in :attr:`TaskResult.messages`. Defaults to True for backward compatibility.
+ """
...
def run_stream(
@@ -39,6 +46,7 @@ class TaskRunner(Protocol):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> AsyncGenerator[BaseAgentEvent | BaseChatMessage | TaskResult, None]:
"""Run the task and produces a stream of messages and the final result
:class:`TaskResult` as the last item in the stream.
@@ -47,5 +55,11 @@ class TaskRunner(Protocol):
The runner is stateful and a subsequent call to this method will continue
from where the previous call left off. If the task is not specified,
- the runner will continue with the current task."""
+ the runner will continue with the current task.
+
+ Args:
+ task: The task to run. Can be a string, a single message, or a sequence of messages.
+ cancellation_token: The cancellation token to kill the task immediately.
+ output_task_messages: Whether to include task messages in the output stream. Defaults to True for backward compatibility.
+ """
...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 0d81c3913..9a078bd42 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -217,6 +217,7 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> TaskResult:
"""Run the team and return the result. The base implementation uses
:meth:`run_stream` to run the team and then returns the final result.
@@ -307,6 +308,7 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
async for message in self.run_stream(
task=task,
cancellation_token=cancellation_token,
+ output_task_messages=output_task_messages,
):
if isinstance(message, TaskResult):
result = message
@@ -319,6 +321,7 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
*,
task: str | BaseChatMessage | Sequence[BaseChatMessage] | None = None,
cancellation_token: CancellationToken | None = None,
+ output_task_messages: bool = True,
) -> AsyncGenerator[BaseAgentEvent | BaseChatMessage | TaskResult, None]:
"""Run the team and produces a stream of messages and the final result
of the type :class:`~autogen_agentchat.base.TaskResult` as the last item in the stream. Once the
@@ -336,6 +339,7 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
Setting the cancellation token potentially put the team in an inconsistent state,
and it may not reset the termination condition.
To gracefully stop the team, use :class:`~autogen_agentchat.conditions.ExternalTermination` instead.
+ output_task_messages (bool): Whether to include task messages in the output stream. Defaults to True for backward compatibility.
Returns:
stream: an :class:`~collections.abc.AsyncGenerator` that yields :class:`~autogen_agentchat.messages.BaseAgentEvent`, :class:`~autogen_agentchat.messages.BaseChatMessage`, and the final result :class:`~autogen_agentchat.base.TaskResult` as the last item in the stream.
@@ -416,7 +420,6 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
asyncio.run(main())
"""
-
# Create the messages list if the task is a string or a chat message.
messages: List[BaseChatMessage] | None = None
if task is None:
@@ -497,14 +500,15 @@ class BaseGroupChat(Team, ABC, ComponentBase[BaseModel]):
# The group chat manager will start the group chat by relaying the message to the participants
# and the group chat manager.
await self._runtime.send_message(
- GroupChatStart(messages=messages),
+ GroupChatStart(messages=messages, output_task_messages=output_task_messages),
recipient=AgentId(type=self._group_chat_manager_topic_type, key=self._team_id),
cancellation_token=cancellation_token,
)
# Collect the output messages in order.
output_messages: List[BaseAgentEvent | BaseChatMessage] = []
stop_reason: str | None = None
- # Yield the messsages until the queue is empty.
+
+ # Yield the messages until the queue is empty.
while True:
message_future = asyncio.ensure_future(self._output_message_queue.get())
if cancellation_token is not None:
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
index 6c008bef6..48feee601 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
@@ -105,8 +105,11 @@ class BaseGroupChatManager(SequentialRoutedAgent, ABC):
GroupChatStart(messages=message.messages),
topic_id=DefaultTopicId(type=self._output_topic_type),
)
- for msg in message.messages:
- await self._output_message_queue.put(msg)
+
+ # Only put messages in output queue if output_task_messages is True
+ if message.output_task_messages:
+ for msg in message.messages:
+ await self._output_message_queue.put(msg)
# Relay all messages at once to participants
await self.publish_message(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
index febb69e60..49d9a6322 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
@@ -41,6 +41,9 @@ class GroupChatStart(BaseModel):
messages: List[BaseChatMessage] | None = None
"""An optional list of messages to start the group chat."""
+ output_task_messages: bool = True
+ """Whether to include task messages in the output. Defaults to True for backward compatibility."""
+
class GroupChatAgentResponse(BaseModel):
"""A response published to a group chat."""
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 5f9f3cf47..646d27212 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -14,6 +14,7 @@ from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.agents._assistant_agent import AssistantAgentConfig
from autogen_agentchat.base import Handoff, Response, TaskResult
from autogen_agentchat.messages import (
+ BaseAgentEvent,
BaseChatMessage,
HandoffMessage,
MemoryQueryEvent,
@@ -903,6 +904,119 @@ class TestAssistantAgentInitialization:
assert agent._metadata == metadata # type: ignore[reportPrivateUsage]
+ @pytest.mark.asyncio
+ async def test_output_task_messages_false(self) -> None:
+ """Test agent with output_task_messages=False.
+
+ Verifies that:
+ 1. Task messages are excluded from result when output_task_messages=False
+ 2. Only agent response messages are included in output
+ 3. Both run and run_stream respect the parameter
+ """
+ model_client = ReplayChatCompletionClient(
+ [
+ CreateResult(
+ finish_reason="stop",
+ content="Agent response without task message",
+ usage=RequestUsage(prompt_tokens=10, completion_tokens=8),
+ cached=False,
+ ),
+ CreateResult(
+ finish_reason="stop",
+ content="Second agent response",
+ usage=RequestUsage(prompt_tokens=10, completion_tokens=5),
+ cached=False,
+ ),
+ ],
+ model_info={
+ "function_calling": False,
+ "vision": False,
+ "json_output": False,
+ "family": ModelFamily.GPT_4O,
+ "structured_output": False,
+ },
+ )
+
+ agent = AssistantAgent(name="test_agent", model_client=model_client)
+
+ # Test run() with output_task_messages=False
+ result = await agent.run(task="Test task message", output_task_messages=False)
+
+ # Should only contain the agent's response, not the task message
+ assert len(result.messages) == 1
+ assert isinstance(result.messages[0], TextMessage)
+ assert result.messages[0].content == "Agent response without task message"
+ assert result.messages[0].source == "test_agent" # Test run_stream() with output_task_messages=False
+ # Create a new model client for streaming test to avoid response conflicts
+ stream_model_client = ReplayChatCompletionClient(
+ [
+ CreateResult(
+ finish_reason="stop",
+ content="Stream agent response",
+ usage=RequestUsage(prompt_tokens=10, completion_tokens=5),
+ cached=False,
+ ),
+ ],
+ model_info={
+ "function_calling": False,
+ "vision": False,
+ "json_output": False,
+ "family": ModelFamily.GPT_4O,
+ "structured_output": False,
+ },
+ )
+
+ stream_agent = AssistantAgent(name="test_agent", model_client=stream_model_client)
+ streamed_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ final_result: TaskResult | None = None
+
+ async for message in stream_agent.run_stream(task="Test task message", output_task_messages=False):
+ if isinstance(message, TaskResult):
+ final_result = message
+ else:
+ streamed_messages.append(message)
+
+ # Verify streaming behavior
+ assert final_result is not None
+ assert len(final_result.messages) == 1
+ assert isinstance(final_result.messages[0], TextMessage)
+ assert final_result.messages[0].content == "Stream agent response"
+
+ # Verify that no task message was streamed
+ task_messages = [msg for msg in streamed_messages if isinstance(msg, TextMessage) and msg.source == "user"]
+ assert len(task_messages) == 0 # Test with multiple task messages
+ multi_model_client = ReplayChatCompletionClient(
+ [
+ CreateResult(
+ finish_reason="stop",
+ content="Multi task response",
+ usage=RequestUsage(prompt_tokens=10, completion_tokens=5),
+ cached=False,
+ ),
+ ],
+ model_info={
+ "function_calling": False,
+ "vision": False,
+ "json_output": False,
+ "family": ModelFamily.GPT_4O,
+ "structured_output": False,
+ },
+ )
+
+ multi_agent = AssistantAgent(name="test_agent", model_client=multi_model_client)
+ task_messages_list = [
+ TextMessage(content="First task", source="user"),
+ TextMessage(content="Second task", source="user"),
+ ]
+
+ result_multi = await multi_agent.run(task=task_messages_list, output_task_messages=False)
+
+ # Should only contain the agent's response, not the multiple task messages
+ assert len(result_multi.messages) == 1
+ assert isinstance(result_multi.messages[0], TextMessage)
+ assert result_multi.messages[0].source == "test_agent"
+ assert result_multi.messages[0].content == "Multi task response"
+
class TestAssistantAgentValidation:
"""Test suite for AssistantAgent validation.
@@ -3339,69 +3453,3 @@ class TestAssistantAgentMessageContext:
# Verify message conversion
for msg in context_messages:
assert isinstance(msg, (SystemMessage, UserMessage, AssistantMessage))
-
- @pytest.mark.asyncio
- async def test_memory_persistence(self) -> None:
- """Test memory persistence across multiple sessions.
-
- Verifies:
- 1. Memory content persists between sessions
- 2. Memory updates are preserved
- 3. Context is properly restored
- 4. Memory query events are generated correctly
- """
- # Create memory with initial content
- memory = MockMemory(contents=["Initial memory"])
-
- # Create model client
- model_client = ReplayChatCompletionClient(
- [
- CreateResult(
- finish_reason="stop",
- content="Response using memory",
- usage=RequestUsage(prompt_tokens=10, completion_tokens=5),
- cached=False,
- ),
- CreateResult(
- finish_reason="stop",
- content="Response with updated memory",
- usage=RequestUsage(prompt_tokens=10, completion_tokens=5),
- cached=False,
- ),
- ],
- model_info={
- "function_calling": False,
- "vision": False,
- "json_output": False,
- "family": ModelFamily.GPT_4O,
- "structured_output": False,
- },
- )
-
- # Create agent with memory
- agent = AssistantAgent(name="memory_test_agent", model_client=model_client, memory=[memory])
-
- # First session
- result1 = await agent.run(task="First task")
- state = await agent.save_state()
-
- # Add new memory content
- await memory.add(MemoryContent(content="New memory", mime_type="text/plain"))
-
- # Create new agent and restore state
- new_agent = AssistantAgent(name="memory_test_agent", model_client=model_client, memory=[memory])
- await new_agent.load_state(state)
-
- # Second session
- result2 = await new_agent.run(task="Second task")
-
- # Verify memory persistence
- assert isinstance(result1.messages[-1], TextMessage)
- assert isinstance(result2.messages[-1], TextMessage)
- assert result1.messages[-1].content == "Response using memory"
- assert result2.messages[-1].content == "Response with updated memory"
-
- # Verify memory events
- memory_events = [msg for msg in result2.messages if isinstance(msg, MemoryQueryEvent)]
- assert len(memory_events) > 0
- assert any("New memory" in str(event.content) for event in memory_events)
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 9e15eb789..3ded2e0c2 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -261,23 +261,28 @@ async def test_round_robin_group_chat(runtime: AgentRuntime | None) -> None:
assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
- # Test streaming.
+ # Test streaming with default output_task_messages=True.
model_client.reset()
- index = 0
await team.reset()
+ streamed_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ final_stream_result: TaskResult | None = None
async for message in team.run_stream(
task="Write a program that prints 'Hello, world!'",
):
if isinstance(message, TaskResult):
- assert compare_task_results(message, result)
+ final_stream_result = message
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ streamed_messages.append(message)
+ assert final_stream_result is not None
+ assert compare_task_results(final_stream_result, result)
+ # Verify streamed messages match the complete result.messages
+ assert len(streamed_messages) == len(result.messages)
+ for streamed_msg, expected_msg in zip(streamed_messages, result.messages, strict=False):
+ assert compare_messages(streamed_msg, expected_msg)
# Test message input.
# Text message.
model_client.reset()
- index = 0
await team.reset()
result_2 = await team.run(
task=TextMessage(content="Write a program that prints 'Hello, world!'", source="user")
@@ -286,7 +291,6 @@ async def test_round_robin_group_chat(runtime: AgentRuntime | None) -> None:
# Test multi-modal message.
model_client.reset()
- index = 0
await team.reset()
task = MultiModalMessage(content=["Write a program that prints 'Hello, world!'"], source="user")
result_2 = await team.run(task=task)
@@ -298,6 +302,104 @@ async def test_round_robin_group_chat(runtime: AgentRuntime | None) -> None:
assert compare_messages(result.messages[i], result_2.messages[i])
+async def test_round_robin_group_chat_output_task_messages_false(runtime: AgentRuntime | None) -> None:
+ model_client = ReplayChatCompletionClient(
+ [
+ 'Here is the program\n ```python\nprint("Hello, world!")\n```',
+ "TERMINATE",
+ ],
+ )
+ with tempfile.TemporaryDirectory() as temp_dir:
+ code_executor_agent = CodeExecutorAgent(
+ "code_executor", code_executor=LocalCommandLineCodeExecutor(work_dir=temp_dir)
+ )
+ coding_assistant_agent = AssistantAgent(
+ "coding_assistant",
+ model_client=model_client,
+ )
+ termination = TextMentionTermination("TERMINATE")
+ team = RoundRobinGroupChat(
+ participants=[coding_assistant_agent, code_executor_agent],
+ termination_condition=termination,
+ runtime=runtime,
+ )
+ result = await team.run(
+ task="Write a program that prints 'Hello, world!'",
+ output_task_messages=False,
+ )
+ expected_messages = [
+ 'Here is the program\n ```python\nprint("Hello, world!")\n```',
+ "Hello, world!",
+ "TERMINATE",
+ ]
+ for i in range(len(expected_messages)):
+ produced_message = result.messages[i]
+ assert isinstance(produced_message, TextMessage)
+ content = produced_message.content.replace("\r\n", "\n").rstrip("\n")
+ assert content == expected_messages[i]
+
+ assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
+
+ # Test streaming with output_task_messages=False.
+ model_client.reset()
+ await team.reset()
+ streamed_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ final_stream_result: TaskResult | None = None
+ async for message in team.run_stream(
+ task="Write a program that prints 'Hello, world!'",
+ output_task_messages=False,
+ ):
+ if isinstance(message, TaskResult):
+ final_stream_result = message
+ else:
+ streamed_messages.append(message)
+ assert final_stream_result is not None
+ assert compare_task_results(final_stream_result, result)
+ # Verify streamed messages match the complete result.messages excluding the first task message
+ assert len(streamed_messages) == len(result.messages) # Exclude task message
+ for streamed_msg, expected_msg in zip(streamed_messages, result.messages, strict=False):
+ assert compare_messages(streamed_msg, expected_msg)
+
+ # Test message input with output_task_messages=False.
+ # Text message.
+ model_client.reset()
+ await team.reset()
+ streamed_messages_2: List[BaseAgentEvent | BaseChatMessage] = []
+ final_stream_result_2: TaskResult | None = None
+ async for message in team.run_stream(
+ task=TextMessage(content="Write a program that prints 'Hello, world!'", source="user"),
+ output_task_messages=False,
+ ):
+ if isinstance(message, TaskResult):
+ final_stream_result_2 = message
+ else:
+ streamed_messages_2.append(message)
+ assert final_stream_result_2 is not None
+ assert compare_task_results(final_stream_result_2, result)
+ # Verify streamed messages match the complete result.messages excluding the first task message
+ assert len(streamed_messages_2) == len(result.messages)
+ for streamed_msg, expected_msg in zip(streamed_messages_2, result.messages, strict=False):
+ assert compare_messages(streamed_msg, expected_msg)
+
+ # Test multi-modal message with output_task_messages=False.
+ model_client.reset()
+ await team.reset()
+ task = MultiModalMessage(content=["Write a program that prints 'Hello, world!'"], source="user")
+ streamed_messages_3: List[BaseAgentEvent | BaseChatMessage] = []
+ final_stream_result_3: TaskResult | None = None
+ async for message in team.run_stream(task=task, output_task_messages=False):
+ if isinstance(message, TaskResult):
+ final_stream_result_3 = message
+ else:
+ streamed_messages_3.append(message)
+ assert final_stream_result_3 is not None
+ # Verify streamed messages exclude the task message
+ assert len(streamed_messages_3) == len(final_stream_result_3.messages)
+ for streamed_msg, expected_msg in zip(streamed_messages_3, final_stream_result_3.messages, strict=False):
+ assert compare_messages(streamed_msg, expected_msg)
+
+
@pytest.mark.asyncio
async def test_round_robin_group_chat_with_team_event(runtime: AgentRuntime | None) -> None:
model_client = ReplayChatCompletionClient(
@@ -333,18 +435,36 @@ async def test_round_robin_group_chat_with_team_event(runtime: AgentRuntime | No
assert isinstance(result.messages[5], SelectSpeakerEvent)
assert isinstance(result.messages[6], TextMessage)
- # Test streaming.
+ # Test streaming with default output_task_messages=True.
model_client.reset()
- index = 0
await team.reset()
+ streamed_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ final_stream_result: TaskResult | None = None
async for message in team.run_stream(
task="Write a program that prints 'Hello, world!'",
):
if isinstance(message, TaskResult):
- assert compare_task_results(message, result)
+ final_stream_result = message
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ streamed_messages.append(message)
+ assert final_stream_result is not None
+ assert compare_task_results(final_stream_result, result)
+ # Verify streamed messages match the complete result.messages
+ assert len(streamed_messages) == len(result.messages)
+ for streamed_msg, expected_msg in zip(streamed_messages, result.messages, strict=False):
+ assert compare_messages(streamed_msg, expected_msg)
+
+ # Test multi-modal message.
+ model_client.reset()
+ await team.reset()
+ task = MultiModalMessage(content=["Write a program that prints 'Hello, world!'"], source="user")
+ result_2 = await team.run(task=task)
+ assert isinstance(result.messages[0], TextMessage)
+ assert isinstance(result_2.messages[0], MultiModalMessage)
+ assert result.messages[0].content == task.content[0]
+ assert len(result.messages[1:]) == len(result_2.messages[1:])
+ for i in range(1, len(result.messages)):
+ assert compare_messages(result.messages[i], result_2.messages[i])
@pytest.mark.asyncio
@@ -492,7 +612,7 @@ async def test_round_robin_group_chat_with_tools(runtime: AgentRuntime | None) -
# Test streaming.
await tool_use_agent._model_context.clear() # pyright: ignore
model_client.reset()
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
async for message in team.run_stream(
task="Write a program that prints 'Hello, world!'",
@@ -500,13 +620,12 @@ async def test_round_robin_group_chat_with_tools(runtime: AgentRuntime | None) -
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test Console.
await tool_use_agent._model_context.clear() # pyright: ignore
model_client.reset()
- index = 0
await team.reset()
result2 = await Console(team.run_stream(task="Write a program that prints 'Hello, world!'"))
assert compare_task_results(result2, result)
@@ -681,7 +800,7 @@ async def test_selector_group_chat(runtime: AgentRuntime | None) -> None:
# Test streaming.
model_client.reset()
agent1._count = 0 # pyright: ignore
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
async for message in team.run_stream(
task="Write a program that prints 'Hello, world!'",
@@ -689,13 +808,12 @@ async def test_selector_group_chat(runtime: AgentRuntime | None) -> None:
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test Console.
model_client.reset()
agent1._count = 0 # pyright: ignore
- index = 0
await team.reset()
result2 = await Console(team.run_stream(task="Write a program that prints 'Hello, world!'"))
assert compare_task_results(result2, result)
@@ -802,7 +920,7 @@ async def test_selector_group_chat_with_team_event(runtime: AgentRuntime | None)
# Test streaming.
model_client.reset()
agent1._count = 0 # pyright: ignore
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
async for message in team.run_stream(
task="Write a program that prints 'Hello, world!'",
@@ -810,8 +928,8 @@ async def test_selector_group_chat_with_team_event(runtime: AgentRuntime | None)
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
@pytest.mark.asyncio
@@ -908,19 +1026,18 @@ async def test_selector_group_chat_two_speakers(runtime: AgentRuntime | None) ->
# Test streaming.
model_client.reset()
agent1._count = 0 # pyright: ignore
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
async for message in team.run_stream(task="Write a program that prints 'Hello, world!'"):
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test Console.
model_client.reset()
agent1._count = 0 # pyright: ignore
- index = 0
await team.reset()
result2 = await Console(team.run_stream(task="Write a program that prints 'Hello, world!'"))
assert compare_task_results(result2, result)
@@ -956,18 +1073,17 @@ async def test_selector_group_chat_two_speakers_allow_repeated(runtime: AgentRun
# Test streaming.
model_client.reset()
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
async for message in team.run_stream(task="Write a program that prints 'Hello, world!'"):
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test Console.
model_client.reset()
- index = 0
await team.reset()
result2 = await Console(team.run_stream(task="Write a program that prints 'Hello, world!'"))
assert compare_task_results(result2, result)
@@ -1171,15 +1287,15 @@ async def test_swarm_handoff(runtime: AgentRuntime | None) -> None:
)
# Test streaming.
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
stream = team.run_stream(task="task")
async for message in stream:
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test save and load.
state = await team.save_state()
@@ -1245,15 +1361,15 @@ async def test_swarm_handoff_with_team_events(runtime: AgentRuntime | None) -> N
)
# Test streaming.
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
stream = team.run_stream(task="task")
async for message in stream:
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
@pytest.mark.asyncio
@@ -1363,20 +1479,19 @@ async def test_swarm_handoff_using_tool_calls(runtime: AgentRuntime | None) -> N
# Test streaming.
await agent1._model_context.clear() # pyright: ignore
model_client.reset()
- index = 0
+ result_index = 0 # Include task message in result since output_task_messages=True by default
await team.reset()
stream = team.run_stream(task="task")
async for message in stream:
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test Console
await agent1._model_context.clear() # pyright: ignore
model_client.reset()
- index = 0
await team.reset()
result2 = await Console(team.run_stream(task="task"))
assert compare_task_results(result2, result)
@@ -1600,13 +1715,13 @@ async def test_round_robin_group_chat_with_message_list(runtime: AgentRuntime |
# Test with streaming
await team.reset()
- index = 0
+ result_index = 0 # Include the 3 task messages in result since output_task_messages=True by default
async for message in team.run_stream(task=messages):
if isinstance(message, TaskResult):
assert compare_task_results(message, result)
else:
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
# Test with invalid message list
with pytest.raises(ValueError, match="All messages in task list must be valid BaseChatMessage types"):
@@ -1804,17 +1919,28 @@ async def test_selector_group_chat_streaming(runtime: AgentRuntime | None) -> No
# Test streaming
await team.reset()
model_client.reset()
- index = 0
- streaming: List[str] = []
- async for message in team.run_stream(task="Write a program that prints 'Hello, world!'"):
+ result_index = 0 # Include task message in result since output_task_messages=True by default
+ streamed_chunks: List[str] = []
+ final_result: TaskResult | None = None
+ async for message in team.run_stream(
+ task="Write a program that prints 'Hello, world!'",
+ ):
if isinstance(message, TaskResult):
+ final_result = message
assert compare_task_results(message, result)
elif isinstance(message, ModelClientStreamingChunkEvent):
- streaming.append(message.content)
+ streamed_chunks.append(message.content)
else:
- if streaming:
+ if streamed_chunks:
assert isinstance(message, SelectorEvent)
- assert message.content == "".join([chunk for chunk in streaming])
- streaming = []
- assert compare_messages(message, result.messages[index])
- index += 1
+ assert message.content == "".join(streamed_chunks)
+ streamed_chunks = []
+ assert compare_messages(message, result.messages[result_index])
+ result_index += 1
+
+ # Verify we got the expected messages without relying on fragile ordering
+ assert final_result is not None
+ assert len(streamed_chunks) == 0 # All chunks should have been processed
+
+ # Content-based verification instead of index-based
+ # Note: The streaming test verifies the streaming behavior, not the final result content
diff --git a/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py b/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py
index 5bc9a010c..875fa06a9 100644
--- a/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py
@@ -1,10 +1,12 @@
from types import MethodType
-from typing import Any, AsyncGenerator, Sequence
+from typing import Any, AsyncGenerator, List, Sequence
import pytest
import pytest_asyncio
from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
-from autogen_agentchat.conditions import MaxMessageTermination
+from autogen_agentchat.base import TaskResult
+from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
+from autogen_agentchat.messages import BaseAgentEvent, BaseChatMessage, TextMessage
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_core import AgentRuntime, SingleThreadedAgentRuntime
from autogen_core.models import CreateResult, LLMMessage, SystemMessage
@@ -59,6 +61,82 @@ async def test_society_of_mind_agent(runtime: AgentRuntime | None) -> None:
assert loaded_soc_agent.name == "society_of_mind"
+async def test_society_of_mind_agent_output_task_messages_parameter(runtime: AgentRuntime | None) -> None:
+ """Test that output_task_messages parameter controls whether task messages are included in the stream."""
+ model_client = ReplayChatCompletionClient(
+ ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+ )
+ agent1 = AssistantAgent("assistant1", model_client=model_client, system_message="You are a helpful assistant.")
+ agent2 = AssistantAgent("assistant2", model_client=model_client, system_message="You are a helpful assistant.")
+ inner_termination = MaxMessageTermination(2) # Reduce to 2 to use fewer responses
+ inner_team = RoundRobinGroupChat([agent1, agent2], termination_condition=inner_termination, runtime=runtime)
+
+ # Test 1: Test team with output_task_messages=True (default behavior)
+ messages_with_task: List[BaseAgentEvent | BaseChatMessage] = []
+ async for message in inner_team.run_stream(task="Count to 10", output_task_messages=True):
+ if not isinstance(message, TaskResult):
+ messages_with_task.append(message)
+
+ # Should include the task message
+ assert len(messages_with_task) >= 1
+ assert any(
+ isinstance(msg, TextMessage) and msg.source == "user" and "Count to 10" in msg.content
+ for msg in messages_with_task
+ )
+
+ # Reset team before next test
+ await inner_team.reset()
+
+ # Test 2: Test team with output_task_messages=False
+ messages_without_task: List[BaseAgentEvent | BaseChatMessage] = []
+ async for message in inner_team.run_stream(task="Count to 10", output_task_messages=False):
+ if not isinstance(message, TaskResult):
+ messages_without_task.append(message)
+
+ # Should NOT include the task message in the stream
+ assert not any(
+ isinstance(msg, TextMessage) and msg.source == "user" and "Count to 10" in msg.content
+ for msg in messages_without_task
+ )
+
+ # Reset team before next test
+ await inner_team.reset()
+
+ # Test 3: Test SocietyOfMindAgent uses output_task_messages=False internally
+ # Create a separate model client for SocietyOfMindAgent to ensure we have enough responses
+ soma_model_client = ReplayChatCompletionClient(
+ ["Final response from society of mind"],
+ )
+ society_of_mind_agent = SocietyOfMindAgent("society_of_mind", team=inner_team, model_client=soma_model_client)
+
+ # Collect all messages from the SocietyOfMindAgent stream
+ soma_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ async for message in society_of_mind_agent.run_stream(task="Count to 10"):
+ if not isinstance(message, TaskResult):
+ soma_messages.append(message)
+
+ # The SocietyOfMindAgent should output the task message (since it's the outer agent)
+ # but should NOT forward the task messages from its inner team
+ task_messages_in_soma = [msg for msg in soma_messages if isinstance(msg, TextMessage) and msg.source == "user"]
+
+ # Count how many times "Count to 10" appears in the stream
+ # With proper implementation, it should appear exactly once (from outer level only)
+ count_task_messages = sum(
+ 1
+ for msg in soma_messages
+ if isinstance(msg, TextMessage) and msg.source == "user" and "Count to 10" in msg.content
+ )
+
+ # Should have exactly one task message (from the outer level only)
+ assert len(task_messages_in_soma) == 1
+ assert count_task_messages == 1 # Should appear exactly once, not duplicated from inner team
+
+ # Should have the SocietyOfMindAgent's final response
+ soma_responses = [msg for msg in soma_messages if isinstance(msg, TextMessage) and msg.source == "society_of_mind"]
+ assert len(soma_responses) == 1
+
+
@pytest.mark.asyncio
async def test_society_of_mind_agent_empty_messges(runtime: AgentRuntime | None) -> None:
model_client = ReplayChatCompletionClient(
@@ -195,3 +273,49 @@ async def test_society_of_mind_agent_yes_multiple_system_messages(
inner_team = RoundRobinGroupChat([agent1, agent2], termination_condition=inner_termination, runtime=runtime)
society_of_mind_agent = SocietyOfMindAgent("society_of_mind", team=inner_team, model_client=model_client_soma)
await society_of_mind_agent.run(task="Count to 10.")
+
+
+async def test_default_output_task_messages_behavior() -> None:
+ """Test that task messages are included by default (backward compatibility)."""
+ # Create inner team
+ model_client = ReplayChatCompletionClient(["Hello", "World", "TERMINATE"])
+ agent1 = AssistantAgent("agent1", model_client=model_client)
+ agent2 = AssistantAgent("agent2", model_client=model_client)
+ termination = TextMentionTermination("TERMINATE")
+ inner_team = RoundRobinGroupChat(participants=[agent1, agent2], termination_condition=termination)
+
+ streamed_messages: List[BaseAgentEvent | BaseChatMessage] = []
+ final_result: TaskResult | None = None
+
+ # Test default behavior (should include task messages since default is True)
+ async for message in inner_team.run_stream(task="Test default behavior"):
+ if isinstance(message, TaskResult):
+ final_result = message
+ else:
+ streamed_messages.append(message)
+
+ # Verify default behavior: task message should be included in stream
+ assert final_result is not None
+ task_message_found_in_stream = any(
+ isinstance(msg, TextMessage) and msg.source == "user" and "Test default behavior" in msg.content
+ for msg in streamed_messages
+ )
+ assert task_message_found_in_stream, "Task message should be included in stream by default"
+
+ # Validate that task message is included in the TaskResult.messages by default
+ task_message_in_result = any(
+ isinstance(msg, TextMessage) and msg.source == "user" and "Test default behavior" in msg.content
+ for msg in final_result.messages
+ )
+ assert task_message_in_result, "Task message should be included in TaskResult.messages by default"
+
+ # Verify the content structure makes sense (task message + agent responses)
+ user_messages = [msg for msg in final_result.messages if isinstance(msg, TextMessage) and msg.source == "user"]
+ agent_messages = [
+ msg for msg in final_result.messages if isinstance(msg, TextMessage) and msg.source in ["agent1", "agent2"]
+ ]
+
+ assert len(user_messages) >= 1, "Should have at least one user message (the task)"
+ assert len(agent_messages) >= 1, "Should have at least one agent response"
+ assert user_messages[0].content == "Test default behavior", "First user message should be the task"