LlmAgent._run_async_impl resume path unconditionally sets end_of_agent=True

[anmol0e]

Bug

LlmAgent._run_async_impl resume path (lines 478-484 in llm_agent.py) unconditionally sets end_of_agent=True after a sub-agent returns, even when the sub-agent paused for a long-running tool call.

# Current code (llm_agent.py:474-484)
if agent_state is not None and (
    agent_to_transfer := self._get_subagent_to_resume(ctx)
):
    async with Aclosing(agent_to_transfer.run_async(ctx)) as agen:
        async for event in agen:
            yield event
    # BUG: unconditional — doesn't check if sub-agent paused
    ctx.set_agent_state(self.name, end_of_agent=True)
    yield self._create_agent_state_event(ctx)
    return

The LLM flow path (lines 486-505) correctly guards with should_pause checks. The resume path is missing the same guards.

Impact

Multi-step HITL workflows break when using Runner.run_async() natively (e.g. via adk web). After the first long-running tool round-trip through a sub-agent, the parent agent sets end_of_agent=True, causing the runner to early-return on subsequent resumes and silently dropping tool responses.

Reproduction

1. Create a parent LlmAgent with a sub-agent
2. Sub-agent has a long-running tool (e.g. is_long_running=True)
3. Run through adk web or native Runner
4. Complete first tool call → resume → sub-agent calls another tool
5. Second tool result is silently dropped

Proposed Fix

Add should_pause guard to the resume path, matching the LLM flow path:

if agent_state is not None and (
    agent_to_transfer := self._get_subagent_to_resume(ctx)
):
    should_pause = False
    async with Aclosing(agent_to_transfer.run_async(ctx)) as agen:
        async for event in agen:
            yield event
            if ctx.should_pause_invocation(event):
                should_pause = True
    if should_pause:
        return
    ctx.set_agent_state(self.name, end_of_agent=True)
    yield self._create_agent_state_event(ctx)
    return

Environment

• google-adk 1.33.0
• Python 3.11

[adk-bot]

I am going to check the instructions for the adk-issue-analyze skill before proceeding with the analysis of Issue #6017.I will now fetch the details of GitHub issue #6017 using the fetch_github_issue tool.I will search for the file llm_agent.py in the workspace to inspect the direct code context.I will search for _run_async_impl in src/google/adk/agents/llm_agent.py using grep_search to find the exact line numbers before viewing the code.I will view src/google/adk/agents/llm_agent.py around line 495 to analyze the logic for resuming sub-agents.I will search for any existing pull requests related to issue #6017 to check if there is an open PR.I will search for test_resumable_llm_agent.py or references to sub-agent resumes to see how resume and pause behaviors are currently tested.I will view the rest of the file tests/unittests/agents/test_resumable_llm_agent.py to understand how long-running/pausable tool calls are tested.I will view the rest of the file tests/unittests/agents/test_resumable_llm_agent.py up to line 265.I will search for should_pause_invocation to see where it is defined and how it is implemented in the codebase.I will inspect invocation_context.py around line 440 to understand how an invocation pause condition is detected.# GitHub Issue #6017 Analysis: LlmAgent._run_async_impl resume path unconditionally sets end_of_agent=True

Executive Summary

1. What is broken? The resume pathway in llm_agent.py unconditionally marks the parent agent as finished (end_of_agent=True) when returning from a resumed subagent, completely omitting checks for pause or long-running tool conditions. This prematurely terminates multi-step Human-in-the-Loop (HITL) or long-running tool sessions, silently dropping subsequent events.
2. Is there a linked PR that fixes this issue? None.
3. Recommendation: Should Fix (High Priority). This is a critical issue affecting developers building multi-agent systems with long-running, asynchronous, or human-in-the-loop workflows. The fix is lightweight, well-contained, and aligns perfectly with ADK's orchestration architecture.

Detailed Analysis

1. Root Cause Analysis ("What is broken?")

The bug originates in the sub-agent resumption logic of LlmAgent._run_async_impl inside llm_agent.py:

    if agent_state is not None and (
        agent_to_transfer := self._get_subagent_to_resume(ctx)
    ):
      async with Aclosing(agent_to_transfer.run_async(ctx)) as agen:
        async for event in agen:
          yield event

      ctx.set_agent_state(self.name, end_of_agent=True)
      yield self._create_agent_state_event(ctx)
      return

• When resuming a sub-agent from storage (e.g., executing a long-running or Human-In-The-Loop tool), agent_to_transfer.run_async(ctx) is run.
• When the sub-agent hits a pause condition, it yields the pause event and exits its execution loop.
• The parent agent captures and yields all events yielded by the sub-agent, and the async for loop finishes.
• However, the parent agent immediately proceeds unconditionally to mark itself as ended on line 509:
  • ctx.set_agent_state(self.name, end_of_agent=True)
  • Yields the agent state event
  • Returns and terminates.
• Because end_of_agent=True is recorded for the parent agent, any subsequent attempts to resume the overall workflow (e.g. providing human feedback or resuming after tool execution) are short-circuited/terminated by the runner, silencing subsequent responses or events.

To compare, the standard LLM flow in llm_agent.py correctly monitors ctx.should_pause_invocation(event) and early returns without setting end_of_agent=True if a pause is triggered:

    should_pause = False
    async with Aclosing(self._llm_flow.run_async(ctx)) as agen:
      async for event in agen:
        self.__maybe_save_output_to_state(event)
        yield event
        if ctx.should_pause_invocation(event):
          # Do not pause immediately, wait until the long-running tool call is
          # executed.
          should_pause = True
    if should_pause:
      return

Proposed Code Solution:

The sub-agent resume loop should be updated to mimic this pause guard:

     if agent_state is not None and (
         agent_to_transfer := self._get_subagent_to_resume(ctx)
     ):
+      should_pause = False
       async with Aclosing(agent_to_transfer.run_async(ctx)) as agen:
         async for event in agen:
           yield event
+          if ctx.should_pause_invocation(event):
+            should_pause = True
+      if should_pause:
+        return
+
       ctx.set_agent_state(self.name, end_of_agent=True)
       yield self._create_agent_state_event(ctx)
       return

Where should_pause_invocation is defined in invocation_context.py.

---

2. Existing Pull Requests ("Is there a linked PR that fixes this issue?")

• Linked PR: None
• PR URL: N/A
• Analysis: We verified using gh pr list --repo google/adk-python --search "6017" that there is currently no open/closed pull request addressing this issue.

---

3. Recommendation

• Recommendation: Should Fix (High Priority)
• Rationale:
  • Severe Impact: Breaks any nested, multi-turn, and resumable child agent workflows that utilize asynchronous or long-running tools (e.g., Web interactions, background jobs, human approval gates). After the first resumption, the parent workflow is prematurely marked ended.
  • Low Implementation Complexity & Risk: The fix requires adding a 6-line conditional block to check ctx.should_pause_invocation during sub-agent invocation, matching the robust style already present in the primary _llm_flow execution layer. This introduces virtually zero structural side-effects or risk.

---

Summary of Work Done

• Analyzed GitHub Issue: Retrieved metadata and description of Issue LlmAgent._run_async_impl resume path unconditionally sets end_of_agent=True #6017.
• Investigated Codebase: Traced LlmAgent._run_async_impl in llm_agent.py and invocation_context.py.
• Verified PR Presence: Searched the repo for any PR matching issue 6017.
• Formulated Proposed Fix & Recommendation: Detailed why the bug occurs, proposed a safe and consistent code diff, and assessed its priority as High.