ADK Bug Report: LongRunningFunctionTool + A2A Protocol Task Completion Issue

Summary

Tasks using LongRunningFunctionTool in A2A protocol never transition to "completed" state, causing frontend clients to wait indefinitely despite the tool function completing successfully.

Environment

• ADK Version: Latest from current branch
• A2A SDK Version: >=0.3.11
• Python Version: 3.12
• LiteLLM Version: 1.80.16
• Pydantic Version: 2.12.5

Problem Description

When agents use LongRunningFunctionTool for async operations, the A2A protocol task state machine gets stuck in "working" state. The tool function executes successfully and returns results, but the task never receives the completion signal, leaving clients waiting indefinitely.

Expected Behavior

1. Client sends A2A request to agent
2. Agent creates task with state "submitted"
3. Agent calls LongRunningFunctionTool function, state changes to "working"
4. Function completes and returns result
5. Task state transitions to "completed"
6. Client receives final response with task completion

Actual Behavior

1. Client sends A2A request to agent ✅
2. Agent creates task with state "submitted" ✅
3. Agent calls LongRunningFunctionTool function, state changes to "working" ✅
4. Function completes and returns result ✅
5. Task state NEVER transitions to "completed" ❌
6. Client never receives final response, waits indefinitely ❌

Reproduction Steps

1. Agent Setup (vision_agent.py)

from google.adk.tools.long_running_tool import LongRunningFunctionTool
from google.adk.agents import Agent

# Async function that takes ~10-30 seconds
async def run_core_analysis_parallel(user_id: str, session_id: str, filename: str) -> str:
    # Perform analysis with LLM calls
    result = await some_async_operation()
    return json.dumps(result)

visual_analysis_agent = Agent(
    name="visual_analyzer",
    model=LiteLlm(model="openai/gpt-5.1"),
    instruction="Analyze images using tools",
    tools=[
        LongRunningFunctionTool(func=run_core_analysis_parallel),
    ],
    planner=plan_re_act_planner.PlanReActPlanner(),
)

app = to_a2a(
    agent=root_agent,
    app=App(
        resumability_config=ResumabilityConfig(is_resumable=True),
        session_service=DatabaseSessionService(db_url=db_url),
        artifact_service=FileArtifactService(root_dir="./artifacts"),
    ),
    credential_service=InMemoryCredentialService(),
)

2. Client Request (A2A JSON-RPC)

// Frontend sends task request
const response = await fetch('http://localhost:8000/', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'task/create',
        params: {
            message: {
                role: 'user',
                parts: [
                    { kind: 'text', text: 'analyze this diagram' },
                    { kind: 'data', data: { artifactRef: {...} } }
                ]
            }
        },
        id: 1
    })
});

3. Observed Behavior

Backend Logs (Vision Agent):

INFO:vision_analysis:Starting bundled core analysis for session_id=...
INFO:vision_analysis:Successfully loaded artifact: image.png (type: image/png)
INFO:LiteLLM: LiteLLM completion() model= gpt-5-mini; provider = openai
[Function executes successfully, returns JSON result]
INFO:     172.19.0.4:51552 - "POST / HTTP/1.1" 200 OK

Frontend Console (Status Updates):

// Repeated status updates, task never completes
Task 60c1186f-cdd7-4d5b-97e2-d82f691b048b status: {
    state: "working",
    message: {
        role: "agent",
        parts: [{
            kind: "data",
            data: {
                name: "run_core_analysis_parallel",
                id: "call_qo2vuDAqGcdmXgKJZ4C4ukrP"
            },
            metadata: {
                adk_type: "function_call",
                adk_is_long_running: true  // <-- Flag set correctly
            }
        }]
    },
    timestamp: "2026-01-13T22:34:37.524618+00:00"
}
// No "completed" state ever arrives

Network Activity:

• Multiple POST requests to orchestrator: 200 OK ✅
• Status-update events streaming correctly ✅
• Final task completion event missing ❌

Root Cause Analysis

The LongRunningFunctionTool sets adk_is_long_running: true metadata correctly, but the A2A task result aggregation mechanism (TaskResultAggregator) doesn't properly handle the completion signal when the async function returns.

Suspected location: google.adk.a2a.executor.a2a_agent_executor.py lines 223-226 where TaskResultAggregator() is created but may not be waiting for long-running tool completion.

Impact

• Severity: High - Blocks all async operations in production A2A agents
• Affected Use Cases:
  • Image/diagram analysis with vision LLMs
  • Document processing pipelines
  • Any operation taking >5 seconds
  • Multi-step agent workflows with sub-agents

Additional Context

Related ADK Components

• google.adk.tools.long_running_tool.LongRunningFunctionTool
• google.adk.a2a.executor.a2a_agent_executor.A2aAgentExecutor
• google.adk.a2a.executor.a2a_agent_executor.TaskResultAggregator
• google.adk.a2a.converters.event_converter.convert_event_to_a2a_events

Expected Fix

The A2A task executor should:

1. Wait for LongRunningFunctionTool async completion
2. Capture the function return value
3. Emit final status-update event with state: "completed"
4. Include tool result in task artifacts or history
5. Close the task properly

Test Case

# Should complete within timeout and return result
async def test_long_running_tool_completion():
    response = await client.send_task(message="analyze image")
    events = []
    async for event in response.stream():
        events.append(event)
        if event.state == "completed":
            break
    
    assert events[-1].state == "completed"  # Currently fails
    assert events[-1].artifacts is not None  # Tool result missing

Note: This issue prevents deployment of production A2A agents that require async operations.