Need some documents about "Swarm", "Supervisor" (all about handoff) pattern

[XinyueZ]

Hey,

I have tried to use sub_agents to implement the supervisor, however, no matter how I write prompts in the supervisor, it only executes the first agent and does not pass information to other agents.

Essentially, it is about the handoff in the transfer between different agents.

Do we need to implement a handoff tool?

Langchain, llama-index, and openai agent SDK all have similar implementations. I would like to ask if ADK has any tips in this regard.

Thank you.

[hangfei]

That's good suggestion. @polong-lin we can consider add some of such patterns.

[boyangsvl]

Hi @XinyueZ , if you can share your code we can help taking a look.

[XinyueZ]

Hey @boyangsvl I define a supervisor to lead agents in making a podcast: plan, draft, preview, final, producer, note-down. Since the EXP version of Gemini 2 does not support public audio generation, I am using the live API run as a tool to replace reading out the podcast in the producer agent, but that is not the main point. My question is, sometimes when it gets to draft or preview, it stops and finishes all, and I don’t know why. My logic is a structure of one supervisor + swarm. I know there is a SequentialAgent, but I am deliberately not using it. Is there a way to define transfers explicitly between agents hand-off tools, similar to LangChain and the OpenAI agent SDK?

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

import asyncio
import os
from typing import Any, AsyncGenerator, Dict, Optional

from dotenv import load_dotenv
from google.adk.agents import Agent, LiveRequest, LiveRequestQueue
from google.adk.agents.callback_context import CallbackContext
from google.adk.agents.run_config import RunConfig, StreamingMode
from google.adk.models import LlmRequest, LlmResponse
from google.adk.runners import Event, Runner
from google.adk.sessions import InMemorySessionService, Session
from google.adk.tools.agent_tool import AgentTool
from google.adk.tools.base_tool import BaseTool
from google.adk.tools.google_search_tool import google_search
from google.adk.tools.tool_context import ToolContext
from google.genai import types
from loguru import logger
from pydantic import BaseModel, Field
from rich.console import Console
from rich.markdown import Markdown

load_dotenv()

os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1"  # os.getenv("GOOGLE_CLOUD_REGION")
os.environ["GOOGLE_CLOUD_PROJECT"] = os.getenv("GOOGLE_CLOUD_PROJECT")
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"


APP_NAME = "podcast_agent_app"
USER_ID = "root_podcast_agent_user"
SESSION_ID_AGENT = "session_root_podcast_agent"

WEB_SEARCH_MODEL = "gemini-2.0-flash"
PLAN_MODEL = "gemini-2.0-flash"
DRAFT_MODEL = "gemini-2.0-flash"
REVIEW_MODEL = "gemini-2.0-flash"
FINAL_MODEL = "gemini-2.0-flash"
PRODUCER_MODEL = "gemini-2.0-flash"
PRODUCER_PODCAST_MODEL = "gemini-2.0-flash-live-preview-04-09"
SUPERVISOR_MODEL = "gemini-2.5-flash-preview-04-17"
NOTE_DOWN_MODEL = "gemini-2.0-flash"

LANGUAGE_CODE = "en-US"

session_service = InMemorySessionService()
session = session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID_AGENT,
)


def _plain_text(text: str):
    # with threading.Lock():
    #     st.success(f"{text}", icon="✨")
    logger.info(text)


def _model_text(text: str):
    # with threading.Lock():
    #     st.success(f"{text}", icon="🧠")
    logger.info(text)


def _agent_text(text: str):
    # with threading.Lock():
    #     st.success(f"{text}", icon="🤖")
    logger.info(text)


def _tool_text(text: str):
    # with threading.Lock():
    #     st.success(f"{text}", icon="💡")
    logger.info(text)


def on_before_agent(callback_context: CallbackContext) -> Optional[types.Content]:
    agent_name = callback_context.agent_name
    _agent_text(f"Agent `{agent_name}` is being checked whether should start...")
    return None


def on_after_agent(callback_context: CallbackContext) -> Optional[types.Content]:
    agent_name = callback_context.agent_name
    _agent_text(f"Agent `{agent_name}` started..")
    return None


def on_before_model_modifier(
    callback_context: CallbackContext, llm_request: LlmRequest
) -> Optional[LlmResponse]:
    agent_name = callback_context.agent_name
    _model_text(f"Agent `{agent_name}` is thinking...")
    return None


def on_after_model_modifier(
    callback_context: CallbackContext, llm_response: LlmResponse
) -> Optional[LlmResponse]:
    agent_name = callback_context.agent_name
    _model_text(f"Agent `{agent_name}` has finished thinking.")
    return None


def on_before_tool_modifier(
    tool: BaseTool, args: Dict[str, Any], tool_context: ToolContext
) -> Optional[Dict]:
    agent_name = tool_context.agent_name
    tool_name = tool.name
    _tool_text(f"Tool `{tool_name}` used with agent `{agent_name}`, please wait...")
    return None


def on_after_tool_modifier(
    tool: BaseTool, args: Dict[str, Any], tool_context: ToolContext, tool_response: Dict
) -> Optional[Dict]:
    agent_name = tool_context.agent_name
    tool_name = tool.name
    _tool_text(
        f"Tool `{tool_name}` used with agent `{agent_name}`, please wait, I will give answer."
    )
    return None


def note_down(result: str) -> dict:
    """Note down the result in markdown format.

    Args:
        result (str): The result in markdown format.

    Returns:
        dict: status
    """
    logger.debug(f"Noting result")
    console = Console(record=True, soft_wrap=True)
    md = Markdown(result, justify="left")
    console.print(md)

    _plain_text(result)

    return {"status": "success", "content": result}


web_search_tool = AgentTool(
    agent=Agent(
        model=WEB_SEARCH_MODEL,
        name="web_search_tool",
        description="An agent providing web search grounding capability",
        instruction="""Answer the user's question directly using web search grounding tool; 
    Provide a brief but concise response. 
    Rather than a detail response. Do not ask the user to check or look up information for themselves, that's your role; do your best to be informative.""",
        tools=[google_search],
    )
)


class PodcastProducerAgentInputSchema(BaseModel):
    transcript: str = Field(
        description="The transcript of the conversation between the hosts: contains the transcript of the conversation between the hosts."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )


podcast_producer_agent = Agent(
    name="podcast_producer_agent",
    model=PRODUCER_PODCAST_MODEL,
    description="""A highly professional agent for generating podcast audio from transcript and host information.""",
    instruction="""You are a professional podcast audio producer. Your task is to read aloud only the conversation between the two hosts, strictly following the provided transcript and host information.

Input:
- transcript: The full conversation transcript between two hosts, in plain text. Only the conversation should be used.
- host_1: Information about the first host (e.g., name, gender, style, etc).
- host_2: Information about the second host (e.g., name, gender, style, etc).

Instructions:
1. Read out only the conversation between the hosts. Do NOT include any other information, such as title, music, intro, outro, or prompts.
2. For each line, use the host information—especially gender, personality, and style—to mimic the appropriate tone, voice, and speaking style of the speaking host. Do NOT explicitly say the host's name; use only natural voice acting to distinguish speakers.
3. The output must be a natural, professional podcast conversation, with clear distinction between the two hosts' voices and personalities through voice acting and tone, not by narration or labels.
4. Absolutely do NOT add or read any content other than the hosts' conversation. No system messages, labels, or extra narration.
5. The result should sound like a real podcast, strictly limited to the hosts' dialogue, and the listener can distinguish the speakers by their voice and style.
""",
    input_schema=PodcastProducerAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["AUDIO"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


async def produce_podcast(transcript: str, host_1: str, host_2: str):
    """Produce podcast audio from transcript and host information.

    Args:
        transcript (str): The transcript of the podcast.
        host_1 (str): The host 1 of the podcast.
        host_2 (str): The host 2 of the podcast.
    """

    async def call_agent_audio_async(
        session: Session,
        live_request_queue: LiveRequestQueue,
        run_config: RunConfig,
        user_input: str,
    ) -> bytes:
        def has_inline_data(event: Event) -> bool:
            return (
                event.content
                and event.content.parts
                and len(event.content.parts) > 0
                and event.content.parts[0].inline_data is not None
            )

        async def client2agent(live_request_queue: LiveRequestQueue, user_input: str):
            """Run agent to send user input to agent."""
            content = types.Content(
                role="user", parts=[types.Part.from_text(text=user_input)]
            )
            request = LiveRequest(content=content, close=False)
            live_request_queue.send(request)

        async def agent2client(live_events: AsyncGenerator[Event, None]) -> bytes:
            audio_data = b""
            async for event in live_events:
                if event.turn_complete:
                    return audio_data
                if has_inline_data(event):
                    logger.debug("🎶")
                    audio_data += event.content.parts[0].inline_data.data

        live_events = runner.run_live(
            session=session,
            live_request_queue=live_request_queue,
            run_config=run_config,
        )
        task_client2agent = asyncio.create_task(
            client2agent(live_request_queue=live_request_queue, user_input=user_input)
        )
        task_agent2client = asyncio.create_task(agent2client(live_events))
        await asyncio.gather(task_client2agent, task_agent2client)
        return task_agent2client.result()

    runner = Runner(
        agent=podcast_producer_agent,
        app_name=APP_NAME,
        session_service=session_service,
    )
    live_request_queue = LiveRequestQueue()
    user_input = f"""I have podcast transcript and additional information for you to generate the final podcast:

host_1: {host_1}

host_2: {host_2}

transcript: 
---Start of transcript---
{transcript}
---End of transcript---
"""
    audio_data = await call_agent_audio_async(
        session=session,
        live_request_queue=live_request_queue,
        run_config=RunConfig(
            response_modalities=["AUDIO"],
            streaming_mode=StreamingMode.NONE,
            speech_config=types.SpeechConfig(
                language_code=LANGUAGE_CODE,
            ),
        ),
        user_input=user_input,
    )
    live_request_queue.close()

    import wave

    with wave.open("./output/adk_podcast.wav", "wb") as wf:
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)
        wf.writeframes(audio_data)
        logger.success("Audio saved to ./output/adk_podcast.wav")


class NoteDownAgentInputSchema(BaseModel):
    text: str = Field(description="The text of information that can note down")


note_down_agent = Agent(
    name="note_down_agent",
    model=NOTE_DOWN_MODEL,
    description="""Agent for noting down the information using `note_down` tool.""",
    instruction="""As `note_down_agent`, you will note down the input information in plain text format. 
- Call the `note_down` tool to complete the note.
- Do not perform any other actions.
""",
    input_schema=NoteDownAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[note_down],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class PlanAgentInputSchema(BaseModel):
    topic_source: str = Field(
        description="The topic source: contains the origin information of the topic, this can be anything."
    )
    podcast_flavor: str = Field(
        description="The podcast flavor: contains what kind of podcast should be created based on the `topic_source`."
    )
    host_1: str = Field(description="The host 1: contains the host 1 of the podcast.")
    host_2: str = Field(description="The host 2: contains the host 2 of the podcast.")
    language: str = Field(
        description="The language of the podcast: contains the language of the podcast."
    )


plan_agent = Agent(
    name="plan_agent",
    model=PLAN_MODEL,
    description="""Agent for planning the podcast.""",
    instruction="""As `plan_agent`, you will plan the podcast in plain text format. 
You get input from user and try to make tha plan for a podcast with 2 people, one male and one female. 
In order to make a plan, you will have the scheme of 

{
"topic_source": ".....", // contains the origin information of the topic, this can be anything.
"podcast_flavor": "...." // contains what kind of podcast should be created based on the topic_source.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
"language": "...." // contains the language of the podcast.
}

as input from user. 

After finish plan, tant to `draft_agent`.

IMPORTANT: You can use `web_search_tool` tool to get the information you need.

Do not perform any other actions.""",
    input_schema=PlanAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[web_search_tool],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class DraftAgentInputSchema(BaseModel):
    topic_source: str = Field(
        description="The topic source: contains the origin information of the topic, this can be anything."
    )
    podcast_flavor: str = Field(
        description="The podcast flavor: contains what kind of podcast should be created based on the `topic_source`."
    )
    plan: str = Field(
        description="The plan for the podcast from `plan_agent`: contains the plan for creating the podcast."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )
    language: str = Field(
        description="The language of the podcast: contains the language of the podcast."
    )


draft_agent = Agent(
    name="draft_agent",
    model=DRAFT_MODEL,
    description="""Agent for drafting the podcast based on the plan.""",
    instruction="""As `draft_agent`, you will draft the podcast in plain text format. 
In order to draft the podcast, you will have the scheme of 

{
"topic_source": ".....", // contains the origin information of the topic, this can be anything.
"podcast_flavor": "...." // contains what kind of podcast should be created based on the topic_source.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
"plan": "...." // contains the plan for the podcast from plan_agent.
"language": "...." // contains the language of the podcast.
}

as input from user. 

After finish draft, tant to `review_agent`.

IMPORTANT: You can use `web_search_tool` tool to get the information you need.

Do not perform any other actions.""",
    input_schema=DraftAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[web_search_tool],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class ReviewAgentInputSchema(BaseModel):
    topic_source: str = Field(
        description="The topic source: contains the origin information of the topic, this can be anything."
    )
    podcast_flavor: str = Field(
        description="The podcast flavor: contains what kind of podcast should be created based on the `topic_source`."
    )
    plan: str = Field(
        description="The plan for the podcast from `plan_agent`: contains the plan for creating the podcast."
    )
    draft: str = Field(
        description="The draft for the podcast from `draft_agent`: contains the draft for creating the podcast."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )
    language: str = Field(
        description="The language of the podcast: contains the language of the podcast."
    )


review_agent = Agent(
    name="review_agent",
    model=REVIEW_MODEL,
    description="""Agent for reviewing the podcast draft togeth with the plan.""",
    instruction="""As `review_agent`, you will review the podcast draft in plain text format.

In order to review the podcast draft, you will have the scheme of 

{
"topic_source": ".....", // contains the origin information of the topic, this can be anything.
"podcast_flavor": "...." // contains what kind of podcast should be created based on the topic_source.
"plan": "...." // contains the plan for the podcast from plan_agent.
"draft": "...." // contains the draft for the podcast from draft_agent.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
"language": "...." // contains the language of the podcast.
}

as input from user. 

After finish review, tant to `final_agent`.
 
IMPORTANT: You can use `web_search_tool` tool to get the information you need.

Do not perform any other actions.""",
    input_schema=ReviewAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[web_search_tool],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class FinalAgentInputSchema(BaseModel):
    topic_source: str = Field(
        description="The topic source: contains the origin information of the topic, this can be anything."
    )
    podcast_flavor: str = Field(
        description="The podcast flavor: contains what kind of podcast should be created based on the `topic_source`."
    )
    plan: str = Field(
        description="The plan for the podcast from `plan_agent`: contains the plan for creating the podcast."
    )
    draft: str = Field(
        description="The draft for the podcast from `draft_agent`: contains the draft for creating the podcast."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )
    review: str = Field(
        description="The review for the podcast from `review_agent`: contains the review for creating the podcast."
    )
    language: str = Field(
        description="The language of the podcast: contains the language of the podcast."
    )


final_agent = Agent(
    name="final_agent",
    model=FINAL_MODEL,
    description="""Agent for finalizing the podcast based on the plan, draft and review.""",
    instruction="""As `final_agent`, you will finalize the podcast in plain text format.

In order to finalize the podcast, you will have the scheme of 

{
"topic_source": ".....", // contains the origin information of the topic, this can be anything.
"podcast_flavor": "...." // contains what kind of podcast should be created based on the topic_source.
"plan": "...." // contains the plan for the podcast from plan_agent.
"draft": "...." // contains the draft for the podcast from draft_agent.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
"review": "...." // contains the review for the podcast from review_agent.
"language": "...." // contains the language of the podcast.
}

as input from user. 

You complete the finalization of the podcast transcript and transfer it with hosts information to `producer_agent`.

IMPORTANT: You can use `web_search_tool` tool to get the information you need.

Do not perform any other actions.""",
    input_schema=FinalAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[web_search_tool],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class PodcastProducerAgentInputSchema(BaseModel):
    transcript: str = Field(
        description="The transcript of the podcast: contains the transcript of the podcast."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )


producer_agent = Agent(
    name="producer_agent",
    model=PRODUCER_MODEL,
    description="""Agent for producing the podcast audio with transcript and hosts information.""",
    instruction="""As `producer_agent`, you will produce the podcast audio.

In order to produce the podcast audio, you will have the scheme of 

{
"transcript": ".....", // contains the origin information of the topic, this can be anything.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
}

as input from user. 

IMPORTANT: 
- You can use `produce_podcast` tool to produce the podcast audio and place in a file.
- After finish producing, transfer with the transcript to `note_down_agent` to note down the finalized podcast transcript.

Do not perform any other actions.""",
    input_schema=PodcastProducerAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    tools=[produce_podcast],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


class SupervisorAgentInputSchema(BaseModel):
    topic_source: str = Field(
        description="The topic source: contains the origin information of the topic, this can be anything."
    )
    podcast_flavor: str = Field(
        description="The podcast flavor: contains what kind of podcast should be created based on the `topic_source`."
    )
    host_1: str = Field(
        description="The host 1 of the podcast: contains the host 1 of the podcast."
    )
    host_2: str = Field(
        description="The host 2 of the podcast: contains the host 2 of the podcast."
    )
    language: str = Field(
        description="The language of the podcast: contains the language of the podcast."
    )


supervisor_agent = Agent(
    name="supervisor_agent",
    model=SUPERVISOR_MODEL,
    description="""Agent as supervisor to lead the team that creates the podcast with specialists.""",
    instruction="""As `supervisor_agent` (leader), you will orchestrate the podcast creation process.

You will have the scheme of 

{
"topic_source": ".....", // contains the origin information of the topic, this can be anything.
"podcast_flavor": "...." // contains what kind of podcast should be created based on the topic_source.
"host_1": "...." // contains the host 1 of the podcast.
"host_2": "...." // contains the host 2 of the podcast.
"language": "...." // contains the language of the podcast.
}

as input from user.     
    
You will use the following agents as specialists to create the podcast, the following order also makes sense:
- `plan_agent`: plan the podcast, after finish plan, then transfer to `draft_agent`.
- `draft_agent`: draft the podcast, after finish draft, then transfer to `review_agent`.
- `review_agent`: review the podcast, after finish review, then transfer to `final_agent`.
- `final_agent`: finalize the podcast, after finish finalizing, then transfer to `producer_agent`.
    - You MUST call `note_down_agent` as the ONLY tool to record the finalized podcast.**
- `producer_agent`: produce the podcast audio, after finish producing, then transfer to `note_down_agent`.



IMPORTANT:
- Do the plan, make the draft, then review the draft with the help of plan and finalize the podcast with all the results of previous steps.
- Your output is just the transcript of the conversation between the hosts as plain text.
- Final output must only contains the conversation between the hosts, no other information, instructions, additional stuffs, also no Intro Music and Outro Music.
- Mandatory to use `producer_agent` ONLY to produce the final podcast, and only at the very end of the process. The produce result is the official record used for all downstream or external tasks.
- Mandatory to use `note_down_agent` tool ONLY to note down the finalized podcast transcript after `producer_agent` finished producing.
- Do not perform any other actions.
""",
    input_schema=SupervisorAgentInputSchema,
    generate_content_config=types.GenerateContentConfig(
        top_p=1.0,
        temperature=1.0,
        top_k=40,
        response_modalities=["TEXT"],
        speech_config=types.SpeechConfig(
            language_code=LANGUAGE_CODE,
        ),
    ),
    sub_agents=[
        plan_agent,
        draft_agent,
        review_agent,
        final_agent,
        producer_agent,
        note_down_agent,
    ],
    before_agent_callback=on_before_agent,
    after_agent_callback=on_after_agent,
    before_model_callback=on_before_model_modifier,
    after_model_callback=on_after_model_modifier,
    before_tool_callback=on_before_tool_modifier,
    after_tool_callback=on_after_tool_modifier,
)


async def main():
    async def call_agent_text_async(query: str, runner, user_id, session_id) -> str:
        content = types.Content(role="user", parts=[types.Part(text=query)])
        async for event in runner.run_async(
            user_id=user_id, session_id=session_id, new_message=content
        ):
            if event.is_final_response():
                if event.content and event.content.parts:
                    return event.content.parts[0].text

    user_input = """ I have the information as following and want to have a podcast about it:

            topic_source: "The U.S 2024 presidential election",
            podcast_flavor: "Discuss fair to both sides of the U.S 2024 presidential election, including some humorous parts.",
            language: "English",
            host_1: "Name: John Doe, gender: male, personality: gentle, intelligent, mild-mannered, easy-going, gentle voice, smart, mild tone, easy-going personality",
            host_2: "Name: Mark Smith, gender: male, personality: direct, intelligent, tough-talking, decisive, strong voice, rugged, tough tone, decisive personality",

    """
    runner = Runner(
        agent=supervisor_agent,
        app_name=APP_NAME,
        session_service=session_service,
    )
    await call_agent_text_async(
        user_input,
        runner=runner,
        user_id=USER_ID,
        session_id=SESSION_ID_AGENT,
    )

    logger.success("Transcript generated successfully")


if __name__ == "__main__":
    asyncio.run(main())