aip-agents-binary 0.5.20__py3-none-any.whl

aip_agents/examples/hello_world_a2a_three_level_agent_hierarchy_client.py

@@ -0,0 +1,244 @@
+"""Three-Level Agent Hierarchy Client.
+
+This client demonstrates connecting to and using a hierarchical agent system
+that manages 3 levels of specialized agents through A2A protocol.
+
+This client tests various scenarios:
+1. Research-only tasks (Level 1 -> Level 2 Research -> Level 3 Workers)
+2. Content-only tasks (Level 1 -> Level 2 Content -> Level 3 Workers)
+3. Complex tasks requiring both research and content creation
+4. Artifact generation across the hierarchy
+
+To run this client:
+1. First start the server: python examples/three_level_agent_hierarchy_server.py
+2. Then run this client: python examples/three_level_agent_hierarchy_client.py
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import asyncio
+import base64
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.schema.agent import A2AClientConfig
+
+load_dotenv()
+
+
+async def main():
+    """Main function demonstrating the Three-Level Agent Hierarchy client."""
+    llm = ChatOpenAI(model="gpt-4.1", streaming=True)
+
+    # Create a simple client agent
+    client_agent = LangGraphAgent(
+        name="HierarchyTestClient",
+        instruction="You are a test client that communicates with hierarchical agent systems via A2A.",
+        model=llm,
+        tools=[],
+    )
+
+    # Discover the hierarchical coordinator agent
+    client_a2a_config = A2AClientConfig(
+        discovery_urls=["http://localhost:8888"],
+    )
+
+    print("=== Three-Level Agent Hierarchy Client ===\n")
+    print("Discovering hierarchical coordinator...")
+
+    try:
+        agent_cards = client_agent.discover_agents(client_a2a_config)
+        if not agent_cards:
+            print("No agents found. Make sure the server is running on http://localhost:9000")
+            print("Start server with: python examples/three_level_agent_hierarchy_server.py")
+            return
+
+        coordinator_card = agent_cards[0]
+        print(f"Found coordinator: {coordinator_card.name}")
+        print(f"Description: {coordinator_card.description}")
+        print(f"Skills: {len(coordinator_card.skills)} available")
+        print()
+
+        # Run test scenarios
+        await test_research_task(client_agent, coordinator_card)
+        await test_content_task(client_agent, coordinator_card)
+        await test_complex_task(client_agent, coordinator_card)
+        await test_artifact_generation(client_agent, coordinator_card)
+
+    except Exception as e:
+        print(f"Error connecting to coordinator: {e}")
+        print("Make sure the server is running: python examples/three_level_agent_hierarchy_server.py")
+
+
+async def test_research_task(client_agent, coordinator_card):
+    """Test a research-only task that flows through research specialists and workers.
+
+    Args:
+        client_agent: The client agent to send the query with.
+        coordinator_card: The agent card of the hierarchical coordinator.
+    """
+    print("--- Test 1: Research Task (Research Specialist -> Data Analysis Worker) ---")
+    query = (
+        "Research the current trends in renewable energy and create a data table showing "
+        "the top 5 technologies with their growth rates and market share."
+    )
+
+    print(f"Query: {query}\n")
+
+    result = client_agent.send_to_agent(agent_card=coordinator_card, message=query)
+    print(f"Response: {result.get('content', 'No content')}")
+
+    handle_artifacts(result, "Research Task")
+    print("\n" + "=" * 80 + "\n")
+
+
+async def test_content_task(client_agent, coordinator_card):
+    """Test a content-only task that flows through content specialists and workers.
+
+    Args:
+        client_agent: The client agent to send the query with.
+        coordinator_card: The agent card of the hierarchical coordinator.
+    """
+    print("--- Test 2: Content Creation Task (Content Specialist -> Writing + Formatting Workers) ---")
+    query = (
+        "Create an engaging blog post about the benefits of remote work, and include "
+        "a professional header image with the title 'Future of Work'."
+    )
+
+    print(f"Query: {query}\n")
+
+    result = client_agent.send_to_agent(agent_card=coordinator_card, message=query)
+    print(f"Response: {result.get('content', 'No content')}")
+
+    handle_artifacts(result, "Content Creation Task")
+    print("\n" + "=" * 80 + "\n")
+
+
+async def test_complex_task(client_agent, coordinator_card):
+    """Test a complex task requiring both research and content specialists.
+
+    Args:
+        client_agent: The client agent to send the query with.
+        coordinator_card: The agent card of the hierarchical coordinator.
+    """
+    print("--- Test 3: Complex Multi-Level Task (Both Specialists + All Workers) ---")
+    query = (
+        "Research the impact of AI on healthcare, analyze the data to create a table showing "
+        "AI applications and their adoption rates, then write a comprehensive report and "
+        "create visual elements including charts and professional graphics."
+    )
+
+    print(f"Query: {query}\n")
+
+    result = client_agent.send_to_agent(agent_card=coordinator_card, message=query)
+    print(f"Response: {result.get('content', 'No content')}")
+
+    handle_artifacts(result, "Complex Multi-Level Task")
+    print("\n" + "=" * 80 + "\n")
+
+
+async def test_artifact_generation(client_agent, coordinator_card):
+    """Test artifact generation across the hierarchy.
+
+    Args:
+        client_agent: The client agent to send the query with.
+        coordinator_card: The agent card of the hierarchical coordinator.
+    """
+    print("--- Test 4: Multi-Artifact Generation (Testing All Workers) ---")
+    query = (
+        "Create a complete analysis package: research cloud computing trends, "
+        "generate data tables with market statistics, write executive summary, "
+        "and create professional presentation graphics including charts and title slides."
+    )
+
+    print(f"Query: {query}\n")
+
+    result = client_agent.send_to_agent(agent_card=coordinator_card, message=query)
+    print(f"Response: {result.get('content', 'No content')}")
+
+    handle_artifacts(result, "Multi-Artifact Generation")
+    print("\n" + "=" * 80 + "\n")
+
+
+def handle_artifacts(result, test_name):
+    """Handle and display information about artifacts from the result.
+
+    Args:
+        result: The result from the agent containing artifacts.
+        test_name: The name of the test for display purposes.
+    """
+    artifacts = result.get("artifacts", [])
+    if artifacts:
+        print(f"\n--- {len(artifacts)} Artifacts Generated by {test_name} ---")
+        for i, artifact in enumerate(artifacts, 1):
+            print(f"Artifact {i}:")
+            print_artifact_info(artifact)
+        print("--- End Artifacts ---")
+    else:
+        print(f"No artifacts generated for {test_name}")
+
+
+def print_artifact_info(artifact: dict) -> None:
+    """Print information about an artifact.
+
+    Args:
+        artifact: Dictionary containing artifact information.
+    """
+    name = artifact.get("name", "unknown")
+    mime_type = artifact.get("mime_type", "unknown")
+    file_data = artifact.get("file_data")
+    description = artifact.get("description", "No description")
+
+    print(f"  Name: {name}")
+    print(f"  Type: {mime_type}")
+    print(f"  Description: {description}")
+
+    if file_data:
+        try:
+            if mime_type == "text/csv":
+                decoded_content = base64.b64decode(file_data).decode("utf-8")
+                lines = decoded_content.split("\n")
+                print(f"  CSV Content ({len(lines)} lines):")
+                # Show first few lines
+                MAX_PREVIEW_LINES = 3
+                for _i, line in enumerate(lines[:MAX_PREVIEW_LINES]):
+                    if line.strip():
+                        print(f"    {line}")
+                if len(lines) > MAX_PREVIEW_LINES:
+                    print(f"    ... and {len(lines) - MAX_PREVIEW_LINES} more lines")
+            elif mime_type.startswith("image/"):
+                file_size = len(base64.b64decode(file_data))
+                print(f"  Image size: {file_size} bytes")
+                print(f"  Image format: {mime_type}")
+            else:
+                data_size = len(file_data)
+                print(f"  File data size: {data_size} characters (base64 encoded)")
+        except Exception as e:
+            print(f"  Could not decode file data: {e}")
+    else:
+        print("  No file data available")
+    print()
+
+
+def print_hierarchy_info():
+    """Print information about the 3-level hierarchy being tested."""
+    print("=== Agent Hierarchy Structure ===")
+    print("Level 1: HierarchicalCoordinator")
+    print("├── Level 2: ResearchSpecialist")
+    print("│   ├── Level 3: WebSearchWorker")
+    print("│   └── Level 3: DataAnalysisWorker (with table_generator)")
+    print("└── Level 2: ContentSpecialist")
+    print("    ├── Level 3: WritingWorker")
+    print("    └── Level 3: FormattingWorker (with image_generator)")
+    print("\nTask Flow:")
+    print("Client -> Coordinator -> Specialist -> Worker -> Results")
+    print("=" * 50)
+    print()
+
+
+if __name__ == "__main__":
+    print_hierarchy_info()
+    asyncio.run(main())

aip_agents/examples/hello_world_a2a_three_level_agent_hierarchy_server.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""Three-Level Agent Hierarchy Server.
+
+This server hosts a hierarchical agent system with three levels:
+1. Level 1 (Coordinator): Main orchestrator agent that handles complex requests
+2. Level 2 (Specialists): Domain-specific agents that handle specialized tasks
+3. Level 3 (Workers): Task-specific agents that perform atomic operations
+
+Architecture:
+Coordinator Agent (A2A Server)
+├── Research Specialist Agent
+│   ├── Web Search Worker Agent
+│   └── Data Analysis Worker Agent
+└── Content Specialist Agent
+    ├── Writing Worker Agent
+    └── Formatting Worker Agent
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.tools.image_artifact_tool import ImageArtifactTool
+from aip_agents.examples.tools.table_generator_tool import TableGeneratorTool
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+load_dotenv()
+
+SERVER_AGENT_NAME = "HierarchicalCoordinator"
+
+
+def create_worker_agents(llm) -> tuple[LangGraphAgent, LangGraphAgent, LangGraphAgent, LangGraphAgent]:
+    """Create Level 3 worker agents that perform atomic operations.
+
+    Args:
+        llm: The language model to use for the worker agents.
+
+    Returns:
+        tuple[LangGraphAgent, LangGraphAgent, LangGraphAgent, LangGraphAgent]: Tuple of (web_search_worker, data_analysis_worker, writing_worker, formatting_worker).
+    """
+    # Research Workers
+    web_search_worker = LangGraphAgent(
+        name="WebSearchWorker",
+        instruction=(
+            "You are a web search specialist. You excel at finding information online. "
+            "When given a topic, provide comprehensive research findings with sources and key insights. "
+            "Format your responses clearly with bullet points and structured information."
+        ),
+        model=llm,
+        tools=[],
+    )
+
+    data_analysis_worker = LangGraphAgent(
+        name="DataAnalysisWorker",
+        instruction=(
+            "You are a data analysis expert. You specialize in creating tables, charts, and analyzing patterns. "
+            "Use the table_generator tool to create structured data representations. "
+            "Always provide insights and interpretations of the data you generate."
+        ),
+        model=llm,
+        tools=[TableGeneratorTool()],
+    )
+
+    # Content Workers
+    writing_worker = LangGraphAgent(
+        name="WritingWorker",
+        instruction=(
+            "You are a content writing specialist. You excel at creating engaging, well-structured content. "
+            "Focus on clarity, readability, and meeting the specific requirements provided. "
+            "Always maintain a professional yet engaging tone."
+        ),
+        model=llm,
+        tools=[],
+    )
+
+    formatting_worker = LangGraphAgent(
+        name="FormattingWorker",
+        instruction=(
+            "You are a formatting and presentation specialist. You excel at creating visual content. "
+            "Use the image_generator tool to create visual elements and graphics. "
+            "Focus on clean, professional layouts and visual appeal."
+        ),
+        model=llm,
+        tools=[ImageArtifactTool()],
+    )
+
+    return web_search_worker, data_analysis_worker, writing_worker, formatting_worker
+
+
+def create_specialist_agents(llm, worker_agents) -> tuple[LangGraphAgent, LangGraphAgent]:
+    """Create Level 2 specialist agents that coordinate worker agents.
+
+    Args:
+        llm: The language model to use for the specialist agents.
+        worker_agents: Tuple of worker agents from create_worker_agents function.
+
+    Returns:
+        tuple[LangGraphAgent, LangGraphAgent]: Tuple of (research_specialist, content_specialist).
+    """
+    web_search_worker, data_analysis_worker, writing_worker, formatting_worker = worker_agents
+
+    research_specialist = LangGraphAgent(
+        name="ResearchSpecialist",
+        instruction=(
+            "You are a research coordinator who manages research and data analysis tasks. "
+            "You delegate web research to WebSearchWorker and data analysis to DataAnalysisWorker. "
+            "For research requests, use WebSearchWorker to gather information. "
+            "For data analysis or table creation requests, use DataAnalysisWorker. "
+            "Synthesize results from your workers into comprehensive research reports."
+        ),
+        model=llm,
+        agents=[web_search_worker, data_analysis_worker],
+    )
+
+    content_specialist = LangGraphAgent(
+        name="ContentSpecialist",
+        instruction=(
+            "You are a content creation coordinator who manages writing and formatting tasks. "
+            "You delegate writing tasks to WritingWorker and visual/formatting tasks to FormattingWorker. "
+            "For text content requests, use WritingWorker to create written material. "
+            "For visual content or formatting requests, use FormattingWorker. "
+            "Ensure all content is cohesive and meets quality standards."
+        ),
+        model=llm,
+        agents=[writing_worker, formatting_worker],
+    )
+
+    return research_specialist, content_specialist
+
+
+def create_coordinator_agent(llm, specialist_agents) -> LangGraphAgent:
+    """Create Level 1 coordinator agent that orchestrates everything.
+
+    Args:
+        llm: The language model to use for the coordinator agent.
+        specialist_agents: Tuple of specialist agents from create_specialist_agents function.
+
+    Returns:
+        LangGraphAgent: The configured coordinator agent.
+    """
+    research_specialist, content_specialist = specialist_agents
+
+    coordinator = LangGraphAgent(
+        name=SERVER_AGENT_NAME,
+        instruction=(
+            "You are a hierarchical coordinator that manages complex multi-step projects. "
+            "You oversee two specialist teams:\n"
+            "- ResearchSpecialist: Handles research, data analysis, and information gathering\n"
+            "- ContentSpecialist: Handles content creation, writing, and visual formatting\n\n"
+            "For each request, analyze what needs to be done and delegate appropriately:\n"
+            "- Research tasks -> ResearchSpecialist\n"
+            "- Content creation tasks -> ContentSpecialist\n"
+            "- Complex requests may require both specialists\n\n"
+            "Always provide a comprehensive summary of the coordinated work and ensure "
+            "all deliverables meet the user's requirements."
+        ),
+        model=llm,
+        agents=[research_specialist, content_specialist],
+    )
+
+    return coordinator
+
+
+@click.command()
+@click.option("--host", "host", default="localhost", help="Host to bind the server to.")
+@click.option("--port", "port", default=8888, help="Port to bind the server to.")
+def main(host: str, port: int):
+    """Runs the Three-Level Agent Hierarchy A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description=(
+            "A hierarchical coordinator managing 3 levels of specialized agents for complex research and content tasks."
+        ),
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="hierarchical_coordination",
+                name="Hierarchical Task Coordination",
+                description="Coordinates complex multi-step projects across 3 levels of specialized agents.",
+                examples=[
+                    "Research market trends and create a presentation",
+                    "Analyze data and write a comprehensive report",
+                    "Create educational content with visuals and data tables",
+                ],
+                tags=["coordination", "hierarchy", "multi-level", "delegation"],
+            ),
+            AgentSkill(
+                id="research_management",
+                name="Research & Analysis Management",
+                description="Manages research specialists and data analysis workers for information gathering.",
+                examples=[
+                    "Research renewable energy trends and create data tables",
+                    "Analyze market competition and generate insights",
+                    "Gather information on AI developments",
+                ],
+                tags=["research", "analysis", "data", "information"],
+            ),
+            AgentSkill(
+                id="content_management",
+                name="Content Creation Management",
+                description="Manages content specialists and formatting workers for content creation.",
+                examples=[
+                    "Create engaging blog posts with visual elements",
+                    "Develop training materials with graphics",
+                    "Write reports with professional formatting",
+                ],
+                tags=["content", "writing", "formatting", "visual"],
+            ),
+        ],
+        tags=["hierarchical", "coordination", "multi-agent", "complex-tasks"],
+    )
+
+    llm = ChatOpenAI(model="gpt-4.1", temperature=0, streaming=True)
+
+    # Build the 3-level hierarchy
+    logger.info("Creating Level 3 worker agents...")
+    worker_agents = create_worker_agents(llm)
+
+    logger.info("Creating Level 2 specialist agents...")
+    specialist_agents = create_specialist_agents(llm, worker_agents)
+
+    logger.info("Creating Level 1 coordinator agent...")
+    coordinator_agent = create_coordinator_agent(llm, specialist_agents)
+
+    app = coordinator_agent.to_a2a(agent_card=agent_card)
+
+    logger.info("A2A application configured. Starting Uvicorn server...")
+    logger.info("Hierarchy: 1 Coordinator -> 2 Specialists -> 4 Workers")
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_a2a_with_metadata_langchain_client.py

@@ -0,0 +1,57 @@
+"""Simple A2A client demonstrating RunnableConfig tool configuration."""
+
+import asyncio
+
+from dotenv import load_dotenv
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.schema.agent import A2AClientConfig
+
+load_dotenv()
+
+
+async def main():
+    """Demonstrate RunnableConfig with agent defaults and runtime overrides."""
+    # Create client agent
+    client = LangGraphReactAgent(
+        name="Client", instruction="You request currency services.", model="openai/gpt-4o-mini"
+    )
+
+    # Discover server agent
+    agents = client.discover_agents(A2AClientConfig(discovery_urls=["http://localhost:8885"]))
+    server_agent = agents[0]
+
+    print("🚀 RunnableConfig Demo: Agent Defaults vs Runtime Overrides")
+    print("=" * 60)
+
+    # Test 1: Agent defaults (premium_corp from server)
+    print("📊 Test 1: Agent Defaults")
+    print("Query: Convert 100 USD to EUR")
+    async for chunk in client.astream_to_agent(server_agent, "Convert 100 USD to EUR"):
+        if chunk.get("content"):
+            print(chunk["content"], end="\n", flush=True)
+        if chunk.get("metadata"):
+            print(f"Metadata: {chunk['metadata']}", end="\n\n", flush=True)
+    print("\n")
+
+    # Test 2: Runtime override (standard_business)
+    print("📊 Test 2: Runtime Override")
+    print("Query: Convert 100 USD to EUR")
+    print("Metadata: Overriding to standard_business tenant")
+
+    metadata = {
+        "tool_configs": {"currency_exchange": {"tenant_id": "standard_business", "auth_key": "standard_key_456"}}
+    }
+
+    async for chunk in client.astream_to_agent(server_agent, "Convert 100 USD to EUR", metadata=metadata):
+        if chunk.get("content"):
+            print(chunk["content"], end="\n", flush=True)
+        if chunk.get("metadata"):
+            print(f"Metadata: {chunk['metadata']}", end="\n\n", flush=True)
+    print("\n")
+
+    print("✅ Demo completed! Notice different rates between premium_corp and standard_business.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_a2a_with_metadata_langchain_server_lm_invoker.py

@@ -0,0 +1,80 @@
+"""Example A2A server for a LangChainAgent Weather Service.
+
+This server instantiates a LangChainAgent with weather lookup capabilities and serves it
+via the A2A protocol using the to_a2a convenience method.
+
+To run this server:
+    python examples/a2a/langchain_server_example.py
+
+It will listen on http://localhost:8001 by default.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from dotenv import load_dotenv
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.examples.hello_world_a2a_langchain_server import SERVER_AGENT_NAME
+from aip_agents.examples.tools.langchain_currency_exchange_tool import CurrencyExchangeTool
+from aip_agents.utils.logger import get_logger
+
+load_dotenv()
+
+logger = get_logger(__name__)
+
+
+@click.command()
+@click.option("--host", "host", default="localhost", help="Host to bind the server to.")
+@click.option("--port", "port", default=8885, help="Port to bind the server to.")
+def main(host: str, port: int):
+    """Runs the LangChain Currency Exchange A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description="A weather agent that provides weather information for cities",
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="currency_exchange",
+                name="Currency Exchange",
+                description="Provides current currency exchange information for cities.",
+                examples=["What's the currency exchange in Tokyo?", "Get currency exchange for London"],
+                tags=["currency_exchange"],
+            )
+        ],
+        tags=["currency_exchange"],
+    )
+
+    agent = LangGraphReactAgent(
+        name="CurrencyAgent",
+        instruction="You are a currency exchange agent. Use the currency_exchange tool for conversions.",
+        model="openai/gpt-4o-mini",
+        tools=[CurrencyExchangeTool()],
+        tool_configs={"currency_exchange": {"tenant_id": "premium_corp", "auth_key": "premium_key_123"}},
+    )
+
+    app = agent.to_a2a(
+        agent_card=agent_card,
+    )
+
+    uvicorn.run(app, host=host, port=port)
+    logger.info("A2A application configured. Starting Uvicorn server...")
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_google_adk.py

@@ -0,0 +1,41 @@
+"""Minimal example demonstrating the GoogleADKAgent with tool usage and async operation.
+
+This example shows how to create a simple calculator agent using Google's ADK
+which automatically handles tool calling and conversation flow.
+"""
+
+import asyncio
+
+from aip_agents.agent.google_adk_agent import GoogleADKAgent
+from aip_agents.examples.tools.adk_arithmetic_tools import sum_numbers
+
+
+async def google_adk_example():
+    """Demonstrates the GoogleADKAgent's arun method."""
+    agent_name = "GoogleADKCalculator"
+
+    # Create the agent with simplified instructions and our tool
+    agent = GoogleADKAgent(
+        name=agent_name,
+        instruction="""You are a calculator assistant. When asked math problems,
+        extract numbers and call sum_numbers tool to add them.
+        For multi-step problems, use multiple tool calls.""",
+        model="gemini-2.0-flash",
+        tools=[sum_numbers],
+        max_iterations=5,  # Allow multiple tool calls if needed
+    )
+
+    # Use the same query as in LangGraph example for consistency
+    query = "What is the sum of 23 and 47? And then add 10 to that, then add 5 more."
+    print(f"--- Agent: {agent_name} ---")
+    print(f"Query: {query}")
+
+    print("\nRunning arun...")
+    response = await agent.arun(query=query)
+    print(f"[arun] Final Response: {response.get('output')}")
+    print("--- End of Google ADK Example ---")
+
+
+if __name__ == "__main__":
+    # GOOGLE_API_KEY should be set in the environment.
+    asyncio.run(google_adk_example())