feat(samples): Add backend blocking poll pattern for HITL workflows

[jpantsjoha]

Summary

This PR adds a backend blocking poll pattern for human-in-the-loop (HITL) approval workflows as an alternative to the existing LongRunningFunctionTool pattern.

Pattern Overview

The backend blocking poll pattern handles polling internally within the tool, allowing the agent to call the approval tool once and receive the final decision without manual intervention.

Key Benefits:

• ✅ Simpler integration: No manual FunctionResponse injection required
• ✅ Seamless UX: Agent waits automatically, no manual "continue" clicks needed
• ✅ Fewer LLM API calls: 1 inference per approval vs. 15+ for agent-level polling
• ✅ Works with poll-only systems: Jira, ServiceNow, email approvals, custom dashboards

---

GitHub Issues Addressed

This pattern directly addresses:

Issue #3184: Parent agent doesn't pause properly for sub-agent approvals

Direct Solution: This pattern eliminates the need for parent agents to pause and resume. The approval tool blocks internally while polling, and the agent naturally waits for the final decision.

Issue #1797: Need HITL event support

Alternative Provided: For systems that don't support webhooks (poll-only systems like Jira, ServiceNow), this pattern provides a simple alternative to webhook-based LongRunningFunctionTool.

---

Files Added

All files in contributing/samples/human_in_loop_blocking_poll/:

Core Implementation

1. blocking_poll_approval_example.py - Synchronous version (standalone agents, low concurrency)
2. blocking_poll_approval_example_async.py - Asynchronous version (production, high concurrency)

Testing Infrastructure

3. mock_approval_api.py - FastAPI-based mock approval server with HTML dashboard
4. test_standalone.py - Standalone sync integration test (no ADK dependencies)
5. test_standalone_async.py - Standalone async integration test
6. test_blocking_poll_core.py - Unit tests with pytest (12 tests)

Documentation

7. README.md - Comprehensive documentation (359 lines) including:
   • Decision matrix (when to use vs. LongRunningFunctionTool)
   • Setup and usage examples
   • Production considerations
   • Performance metrics (93% API call reduction)
   • Troubleshooting guide

---

Test Results

100% Pass Rate (20 tests total):

Integration Tests

• Sync version: 4/4 tests PASSED (4.0s)
• Async version: 4/4 tests PASSED (4.0s)

Unit Tests

• Core logic: 12/12 tests PASSED (0.06s)

All tests validated locally before submission.

---

Production Validation

This pattern has been validated in a production multi-agent RFQ approval system:

Metric	Agent-Level Polling	Backend Blocking Poll
LLM API calls	15+ per approval	1 per approval
Manual user clicks	20+ "continue" clicks	0 clicks
API call reduction	Baseline	93% reduction

Real-World Use Case:

• Multi-agent RFQ approval workflow
• 10-minute average approval duration
• Handled gracefully with no manual intervention

---

When to Use This Pattern

✅ Use Backend Blocking Poll When:

• External system doesn't support webhooks (poll-only)
• Simple approval workflow (single decision)
• Prefer simple application code (no FunctionResponse management)
• Approval typically completes in <10 minutes

⚠️ Use LongRunningFunctionTool When:

• External system supports webhooks or callbacks
• Need to show progress updates to user during waiting
• Multi-step approval workflows with state transitions
• Very long-duration approvals (>10 minutes)

---

Design Decisions

Why Async + Sync Versions?

• Sync version: Simple, straightforward for standalone agents
• Async version: Non-blocking I/O for production multi-agent systems (recommended)

Why Mock API?

Provides complete testing infrastructure without external dependencies, allowing developers to validate the pattern locally.

Why Comprehensive Documentation?

The 359-line README includes:

• Decision matrix to help developers choose the right pattern
• Production validation metrics to demonstrate real-world value
• Detailed comparison with LongRunningFunctionTool to clarify differences

---

Checklist

• All tests passing (100% pass rate)
• Apache 2.0 license headers on all files
• No domain-specific references (generic approval workflows)
• Comprehensive documentation with decision matrix
• Both sync and async versions included
• Mock test infrastructure provided
• Production considerations documented
• GitHub issues (Human in the loop within custom agent and SequentialAgent workflow does not pause execution #3184, human-in-the-loop event support for ADK #1797) addressed

---

Reviewer Notes

This contribution complements the existing human_in_loop sample by providing an alternative pattern for poll-only systems. It does not replace LongRunningFunctionTool but offers a simpler option when webhooks are not available.

Related Samples:

• contributing/samples/human_in_loop/ - Existing LongRunningFunctionTool pattern
• contributing/samples/a2a_human_in_loop/ - A2A human-in-the-loop example

Production Impact:

• Reduces LLM API costs by 93% for approval workflows
• Eliminates manual intervention (no "continue" clicking)
• Works with existing enterprise systems (Jira, ServiceNow, etc.)

[ryanaiagent]

Hi @jpantsjoha, Thank you for your contribution!
We appreciate you taking the time to submit this pull request. Your PR has been received by the team and is currently under review. We will provide feedback as soon as we have an update to share.

[jpantsjoha]

✅ Merge conflicts resolved!

Hi @DeanChensj and @ryanaiagent,

I've successfully resolved the merge conflicts that were blocking this PR. Here's what was completed:

🔧 Conflict Resolution Summary

• Rebased against latest main branch (cf21ca3)
• Resolved conflicts in 4 files:
  • src/google/adk/agents/llm_agent.py
  • src/google/adk/flows/llm_flows/functions.py
  • tests/unittests/agents/test_llm_agent_error_messages.py
  • tests/unittests/flows/llm_flows/test_functions_error_messages.py

📝 Changes Integrated

The conflicts arose because this PR included enhanced error messages that have since been refactored into a shared utility function (format_not_found_error) in the main branch. All conflicts have been resolved to use the new utility approach.

✅ Status

• Branch is now up-to-date with main
• All conflicts resolved
• Ready for review

The PR is now ready for your review. Thank you for your patience during the conflict resolution process!

Note: The core HITL blocking poll pattern functionality remains unchanged - only the error message handling has been updated to align with the latest main branch.

[JpantsjohaCog]

Hi team, just checking in on this. The merge conflicts were resolved on Nov 24. Is there anything else needed for review?

[jpantsjoha]

Hi @ryanaiagent @DeanChensj @Jacksunwei,

Rebased against latest main (v1.25.1) — clean rebase, no conflicts. All 12 unit tests pass on Python 3.12.

Quick recap of what this PR adds:

• Backend blocking poll pattern for HITL workflows (sync + async examples)
• Mock approval API for local testing
• 20 tests (all passing)
• Comprehensive README with decision matrix vs LongRunningFunctionTool

Issues addressed:

• Human in the loop within custom agent and SequentialAgent workflow does not pause execution #3184 — Parent agent pause bug (directly solved by this pattern)
• human-in-the-loop event support for ADK #1797 — HITL event support (alternative for poll-only systems like Jira, ServiceNow)

Key benefit: 93% reduction in LLM API calls vs agent-level polling, with no FunctionResponse injection required.

This has been open since October — would really appreciate a review when you get a chance. Happy to make any changes needed.

Thanks!