How to implement multi-round dialogue with swarm without employing the Console

[Kiyi-Lee]

Does anyone know how to utilize swarm in autogen0.4 to facilitate a multi-round conversation? The official demonstration on the website only employs Console for implementation. How can I accomplish a multi-round setup using gradio or streamlit as the user interface without relying on Console, especially under the condition of need user input messages?

async def run_team_stream() -> None:
task_result = await Console(team.run_stream(task=task))
last_message = task_result.messages[-1]

while isinstance(last_message, HandoffMessage) and last_message.target == "user":
    user_message = input("User: ")

    task_result = await Console(
        team.run_stream(task=HandoffMessage(source="user", target=last_message.source, content=user_message))
    )
    last_message = task_result.messages[-1]

asyncio.run(run_team_stream())

[Ultron (Ultroncn)]

Console is a consumer of the stream, not the component that implements Swarm's conversation state. In AgentChat 0.4+, your web backend can consume team.run_stream() directly and return control to the UI when the team hands off to the user.

For example, this controller function forwards events to your UI callback and returns the agent to resume:

from autogen_agentchat.base import TaskResult
from autogen_agentchat.messages import HandoffMessage

async def run_ui_turn(team, task, emit_event):
    result = None
    async for event in team.run_stream(task=task):
        if isinstance(event, TaskResult):
            result = event
        else:
            await emit_event(event)

    if result is None:
        raise RuntimeError("The stream ended without a TaskResult")

    last = result.messages[-1] if result.messages else None
    if isinstance(last, HandoffMessage) and last.target == "user":
        return last.source
    return None

Here emit_event is an async adapter you implement for your websocket, Gradio, or other UI; serialize/render the event types your UI supports. Configure the team with HandoffTermination(target="user"), as in the Swarm example.

On the first UI submission, pass the task string. When the function returns a pending agent name, store it in that conversation's server-side session. On the next user submission, resume with:

reply = HandoffMessage(
    source="user",
    target=pending_agent_name,
    content=user_text,
)
# Within your async UI handler:
next_pending_agent = await run_ui_turn(team, reply, emit_event)

Keep a separate team/state per conversation, and serialize calls to the same team. Do not recreate/reset the team between these two submissions. If your web framework recreates it on reruns, save its state after the completed turn and load it into an equivalently configured team before resuming. Close the model client when disposing the session, rather than after every message. You do not need a blocking input() loop while the browser waits for user input.

References: stream contract and terminal TaskResult, Swarm handoff validation and resume example.