Tutorial's event handling seems to be wrong

[meteatamel]

Describe the bug

I followed the tutorial where it talks about handling events this way:

final_response_text = "Agent did not produce a final response." # Default

  # Key Concept: run_async executes the agent logic and yields Events.
  # We iterate through events to find the final answer.
  async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content):
      # You can uncomment the line below to see *all* events during execution
      # print(f"  [Event] Author: {event.author}, Type: {type(event).__name__}, Final: {event.is_final_response()}, Content: {event.content}")

      # Key Concept: is_final_response() marks the concluding message for the turn.
      if event.is_final_response():
          if event.content and event.content.parts:
             # Assuming text response in the first part
             final_response_text = event.content.parts[0].text
          elif event.actions and event.actions.escalate: # Handle potential errors/escalations
             final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
          # Add more checks here if needed (e.g., specific error codes)
          break # Stop processing events once the final response is found

  print(f"<<< Agent Response: {final_response_text}")

This makes you think that all you need to do is look for the final event and print its text.

However, in my testing, I found out that before the final event, there are other events with text and the text of these events are NOT included in the final event. If you only look for the final event, then you'll miss some of the text.

Instead I handle events like this:

  response_text = ""

  for event in events:
      if event.is_final_response():
          if event.content and event.content.parts:
             response_text += event.content.parts[0].text
          elif event.actions and event.actions.escalate:
             response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
          break # Stop processing events once the final response is found
      else:
          if event.content and event.content.parts and event.content.parts[0].text:
              response_text += event.content.parts[0].text

  print(f"<<< Agent: {response_text}")

What I'm looking for?
Verification that my understanding is correct and the code to read text should be as I described.

To Reproduce
Steps to reproduce the behavior:

1. Go through the tutorial
2. Setup an agent that returns a big chunk of text
3. Run it multiple times
4. Sometimes, you'll see that the expected text is halfway cut

Expected behavior
The tutorial should show how to handle events properly with large text

[DeanChensj]

Hi @polong-lin , can you help take a look?

[abhishm]

I wrote this small util that you can use for handling even non-text event.

def pretty_print_event(event):
    """Pretty prints an event with truncation for long content."""
    if not event.content:
        print(f"[{event.author}]: {event}")
        return
        
    author = event.author
    parts = event.content.parts
    
    for part in parts:
        if part.text:
            print(f"[{author}]: {part.text}")
        elif part.function_call:
            func_call = part.function_call
            print(f"[{author}]: Function call: {func_call.name}")
            print(f"  Args: {func_call.args}")
        elif "function_response" in part:
            func_response = part.function_response
            print(f"[{author}]: Function response: {func_response.name}")
            print(f"  Response: {func_response.response}")
        elif part.executable_code:
            display(Markdown(f"{part.executable_code.code}"))
        elif part.code_execution_result:
                display(Markdown(f"`{part.code_execution_result.output}`"))
                print("\nOutcome:", part.code_execution_result.outcome)

[meteatamel]

Thanks @abhishm for the pretty print. This piece of code works reliably for me to print the whole stream of text and also debug log the events along the way. Sharing it here in case it's useful:

import asyncio
import logging
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai.types import Content, Part
from travel_helper.agent import root_agent as travel_helper_agent

from dotenv import load_dotenv
load_dotenv()

APP_NAME = "adk_tutorial_app"
USER_ID = "user_1"
SESSION_ID = "session_1"

logger = logging.getLogger(__name__)

def setup_runner(agent):
    session_service = InMemorySessionService()
    session_service.create_session(
        app_name=APP_NAME,
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    print(f"Session created: App='{APP_NAME}', User='{USER_ID}', Session='{SESSION_ID}'")

    runner = Runner(
        agent=agent,
        app_name=APP_NAME,
        session_service=session_service
    )
    print(f"Runner created for agent '{runner.agent.name}'.")
    return runner


async def call_agent(runner, query):
  content = Content(role='user', parts=[Part(text=query)])
  response_text = ""

  async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content):
      pretty_print_event(event)

      if event.is_final_response():
          if event.content and event.content.parts:
             response_text += event.content.parts[0].text
          elif event.actions and event.actions.escalate:
             response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
          break # Stop processing events once the final response is found
      else:
          if event.content and event.content.parts and event.content.parts[0].text:
              response_text += event.content.parts[0].text

  print(f"<<< Agent: {response_text}")


def pretty_print_event(event):
    logger.debug(f"[{event.author}] event, final: {event.is_final_response()}")

    for part in event.content.parts:
        if part.text:
            logger.debug(f"  ==> text: {part.text}")
        elif part.function_call:
            func_call = part.function_call
            logger.debug(f"  ==> func_call: {func_call.name}, args: {func_call.args}")
        elif part.function_response:
            func_response = part.function_response
            logger.debug(f"  ==> func_response: {func_response.name}, response: {func_response.response}")


def setup_logger():
    logger.setLevel(logging.DEBUG)
    handler = logging.StreamHandler()
    formatter = logging.Formatter('%(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)


async def main():
    runner = setup_runner(travel_helper_agent)

    print("Welcome! Start chatting with the agent. Type 'exit' to end.")
    while True:
        user_input = input(">>> User: ")
        if user_input.lower() == 'exit':
            print("Goodbye!")
            break
        await call_agent(runner, user_input)


if __name__ == '__main__':
    setup_logger()
    asyncio.run(main())

[boyangsvl]

When building applications for end users, you usually don't have to deal with events that are not final responses. Those non-final events are mostly for information about what happened in the framework. Could you share with me what events are currently not marked as final but are required to handle for your application?

[meteatamel]

@boyangsvl I get events with "text" field populated but not marked as final. This usually happens when the output is a large text. In that case, the text seems to be broken between final and non-final events. If you're looking for a sample to try, you can try my demo: https://github.com/meteatamel/adk-demos/blob/main/agent_runner/main.py

[polong-lin]

@meteatamel Could you share an example of an output that's not marked as final (via a large output text perhaps as you mentioned)? Are you hitting output token limits which is creating an unexpected response from the agent or something like that?

[meteatamel]

Hi @polong-lin, in my previous message, I shared my sample app that exhibits this behavior. Just run that sample and you should see what I'm seeing. I don't think it's an output token limit. It's just text being split over multiple events.

[tpryan]

Hi Mete and thanks to everyone who participated in this thread.

We're currently doing some housekeeping on our issue tracker. Given the rapid pace of development and the number of updates since this was last active, there's a good chance this issue has been resolved in a newer version. To help us keep our backlog focused on current issues, we are closing this as stale.

If you're still facing this problem, could you please update to the very latest version of the library and confirm the issue still exists? If it does, please comment here, and we will be happy to reopen this issue and investigate further.

Thanks for your contribution and understanding!