Issues with multiple consecutive Long Running Function Tools with HITL

[unxsist]

I'm currently trying to set up a couple of (sub)agents that have long running function tools. I've instructed them to call these functions in a specific sequence based on the information the agent gathered from the user. However, any tool user response after the initial tool user response, doesn't seem to be processed by the agent and it always asks the same question again, however no longer with initiating the function call, so it kind of gets stuck.

At first I thought this had to do with my runtime-layer, but it also happens when testing it via the ADK Web utility.

I've tried many things, but somehow, I can't get this to work. I've shared a simple agent example and I can't figure out what I would be doing wrong. Is there anything crucial that I am currently missing? Any advice on chaining these calls in general?

I've added an "anonymised" sample below, to kind of share what I'm trying to accomplish.

import enum
import os
from typing import List, Optional

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools.long_running_tool import LongRunningFunctionTool


def select_record() -> dict:
    """Fetch a recent set of user-related records to choose from."""
    return {
        "status": "pending",
        "record_id": None,
    }


def identify_affected_components(record_id: str) -> dict:
    """Collect which components/entries are affected within a specific record."""
    return {
        "status": "pending",
        "affected_components": []
    }


def request_supporting_materials(record_id: str, component_ids: List[str]) -> dict:
    """Request supporting materials (e.g., photos, docs) for the selected components."""
    return {
        "status": "pending",
        "materials_review": None
    }


def choose_remedy() -> dict:
    """Let the user choose a remedy path (e.g., credit vs payout)."""
    return {
        "status": "pending",
        "remedy_choice": None
    }


def apply_remedy(choice: str) -> dict:
    """
    Apply the requested remedy.
    Choice can be 'balance_credit' or 'payout'.
    """
    if choice == "balance_credit":
        return {"status": "success", "message": "Remedy applied: balance credit."}
    else:
        return {"status": "success", "message": "Remedy applied: payout."}


def create_resolution_agent() -> LlmAgent:
    """Constructs a neutral ADK agent for generic case resolution."""
    LITELLM_MODEL = os.getenv("LITELLM_MODEL", "gpt-4.1")
    return LlmAgent(
        model=LiteLlm(model=LITELLM_MODEL),
        name="resolution_agent",
        description=(
            "An agent that guides users through resolving issues on a selected record, "
            "gathering details, requesting supporting materials, and applying a chosen remedy."
        ),
        instruction="""
            You are a resolution agent.
            You help users resolve issues on a selected record. Follow these steps and wait for input:

            1. Ask which record this concerns using the select_record tool.
            2. After a record is chosen, ask which components are affected using the identify_affected_components tool.
            3. When components are selected, request supporting materials using the request_supporting_materials tool.
            4. Offer the user a choice of remedy (e.g., balance credit or payout) using the choose_remedy tool.
            5. When the user confirms their selection, acknowledge the choice and execute the apply_remedy tool.
        """,
        tools=[
            LongRunningFunctionTool(func=select_record),
            LongRunningFunctionTool(func=identify_affected_components),
            LongRunningFunctionTool(func=request_supporting_materials),
            LongRunningFunctionTool(func=choose_remedy),
            apply_remedy,
        ],
    )


root_agent = create_resolution_agent()

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: The behavior you're observing is expected. LongRunningFunctionTool is designed to pause the agent to wait for external input, which is crucial for Human-in-the-Loop (HITL) scenarios. Your agent is getting "stuck" because it's not receiving the next event from a client to continue the conversation. You need to implement a client-side logic to handle the "pending" status and send the user's input back to the agent.

---

Hello! I'm an AI assistant, and I'm here to help you with your question about LongRunningFunctionTool.

Based on the information I found, the LongRunningFunctionTool is working as intended in your code. This tool is specifically designed for long-running processes and scenarios that require human intervention (Human-in-the-Loop). When a function decorated with @LongRunningFunctionTool is called, it intentionally pauses the agent's execution and returns a "pending" status. This is to allow an external system or a human to perform an action and then resume the agent's operation with the result of that action.

In your case, the agent calls select_record, gets a "pending" status, and then waits for the "agent client" to send back a response to continue the process. Since there is no client-side logic in your provided code to handle this, the agent appears to be "stuck".

To resolve this, you need to implement a client that interacts with the agent. This client will:

1. Receive the "pending" status from the LongRunningFunctionTool.
2. Gather the necessary input from the user (e.g., the selected record ID).
3. Send this information back to the agent as a new event, so it can proceed to the next step.

A great example of how to implement this client-side logic can be found in the human_in_the_loop.py example in the ADK documentation. [1] This example demonstrates how to build a simple command-line client that interacts with an agent using a LongRunningFunctionTool, which is very similar to what you are trying to achieve.

By implementing a similar client-side logic, your agent will be able to proceed through the sequence of tool calls as you intended.

I hope this helps!

[1] https://github.com/google/adk-docs/blob/main/examples/python/snippets/tools/function-tools/human_in_the_loop.py

[tiaaburton]

Have you tried updating the agent's state with each individual response? This helps create continuity among the tool calls. An alternative could be to add it to the context as an artifact.

[unxsist]

How can I update the agent state via A2A? I am just returning a DataPart containing the Function Response the way ADK expects (metadata) it (as A2A lacks function calling standards)

[unxsist]

How can I update the agent state via A2A? I am just returning a DataPart containing the Function Response the way ADK expects (metadata) it (as A2A lacks function calling standards)

To clarify, this problem occurs both when integrating over A2A or when using the ADK Web UI directly, so not sure if I should be manually managing additional state?

[tiaaburton]

Updating the state allows the responses that are key-value pairs to be saved for reference in the conversation. The standard way is managing the state delta EventActions.state_delta, so that it's not replaced each time you have the HITL LongRunningFunctionTool tool execution.

It's wouldn't be additional state. Once you have the update state logic in place, it uses the available Session Service of those applications to store information that needs to be saved in conversation. For testing outside of ADK Web UI or A2A, you would need to use the InMemorySessionService as depicted in the How State is Updated Recommended Method (see # 2).

[unxsist]

Thanks for the quick replies. In the meantime I've been playing around with trying to set state using the tool callbacks, however, with long running tools, the callbacks never get triggered once I send an updated tool response, as it's no longer a tool invocation.

I guess I am looking for a way to modify state via A2A messages. I'm currently using the get_fast_api_app approach to expose my agents and that's using the A2AAgentExecutor that comes with ADK. I guess this approach currently doesn't support this? I would probably require additional endpoints to manage state then correct?

I've also been looking into plugins, to see if I can create a generic hook that listens for function responses coming back over A2A, but haven't yet found away.

Sorry for the many questions, just trying to wrap my head around this.