fix: retry with resume message when model returns empty response

Some models (notably Gemini 2.5) intermittently return empty content
(parts: [], candidatesTokenCount: 0, finishReason: STOP) after
processing tool results. This is especially common under concurrent
load and with streaming + thinking enabled.

ADK's is_final_response() treats this as a valid completed turn because
it only checks for the absence of function calls, not the presence of
actual content. The agent loop stops and the user sees nothing.

This fix adds retry logic in BaseLlmFlow.run_async():

1. _has_meaningful_content() helper detects empty/thought-only events
2. When an empty final response is detected from the current agent,
   a resume message ("Your previous response was empty. Please resume
   execution from where you left off.") is injected into the session
   as a user event before re-prompting the model
3. Maximum 2 retries to prevent infinite loops
4. Author check (last_event.author == agent.name) prevents false
   positives on legitimate empty events from agent transfers

Unlike a silent re-prompt, the injected message gives the model
context about why it is being called again, improving recovery rate.

Fixes #3525

Author: gurjot-05

src/google/adk/flows/llm_flows/base_llm_flow.py

@@ -65,6 +65,39 @@
 
 _ADK_AGENT_NAME_LABEL_KEY = 'adk_agent_name'
 
+# Maximum number of retries when the model returns an empty response after
+# tool execution. Prevents infinite loops if the model keeps returning empty.
+_MAX_EMPTY_RESPONSE_RETRIES = 2
+
+# Message injected into the conversation when the model returns an empty
+# response, nudging it to resume execution on the next attempt.
+_EMPTY_RESPONSE_RESUME_MESSAGE = (
+    'Your previous response was empty. '
+    'Please resume execution from where you left off.'
+)
+
+
+def _has_meaningful_content(event: Event) -> bool:
+  """Returns whether the event has content worth showing to the user.
+
+  An event with no content, empty parts, or only thought / whitespace parts
+  is not meaningful. Used to detect empty model responses after tool
+  execution so the loop can re-prompt instead of silently halting.
+  """
+  if not event.content or not event.content.parts:
+    return False
+  for part in event.content.parts:
+    if part.function_call or part.function_response:
+      return True
+    if part.thought:
+      continue
+    if part.text and part.text.strip():
+      return True
+    if part.inline_data or part.file_data:
+      return True
+  return False
+
+
 # Timing configuration
 DEFAULT_TRANSFER_AGENT_DELAY = 1.0
 DEFAULT_TASK_COMPLETION_DELAY = 1.0
@@ -748,16 +781,46 @@ async def run_async(
       self, invocation_context: InvocationContext
   ) -> AsyncGenerator[Event, None]:
     """Runs the flow."""
+    empty_response_count = 0
     while True:
       last_event = None
       async with Aclosing(self._run_one_step_async(invocation_context)) as agen:
         async for event in agen:
           last_event = event
           yield event
-      if not last_event or last_event.is_final_response() or last_event.partial:
+      if not last_event or last_event.partial:
         if last_event and last_event.partial:
           logger.warning('The last event is partial, which is not expected.')
         break
+      if last_event.is_final_response():
+        if (
+            not _has_meaningful_content(last_event)
+            and last_event.author == invocation_context.agent.name
+            and empty_response_count < _MAX_EMPTY_RESPONSE_RETRIES
+        ):
+          empty_response_count += 1
+          logger.warning(
+              'Model returned an empty response (attempt %d/%d),'
+              ' injecting resume message and re-prompting.',
+              empty_response_count,
+              _MAX_EMPTY_RESPONSE_RETRIES,
+          )
+          # Inject a resume nudge into the session so the next LLM call
+          # sees it in its context and is more likely to continue.
+          resume_event = Event(
+              invocation_id=invocation_context.invocation_id,
+              author='user',
+              branch=invocation_context.branch,
+              content=types.Content(
+                  role='user',
+                  parts=[
+                      types.Part.from_text(text=_EMPTY_RESPONSE_RESUME_MESSAGE)
+                  ],
+              ),
+          )
+          yield resume_event
+          continue
+        break
 
   async def _run_one_step_async(
       self,

tests/unittests/flows/llm_flows/test_empty_response_retry.py

@@ -0,0 +1,168 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for empty model response retry logic in BaseLlmFlow.run_async."""
+
+from google.adk.events.event import Event
+from google.adk.events.event_actions import EventActions
+from google.adk.flows.llm_flows.base_llm_flow import _has_meaningful_content
+from google.adk.flows.llm_flows.base_llm_flow import _MAX_EMPTY_RESPONSE_RETRIES
+from google.genai import types
+import pytest
+
+
+class TestHasMeaningfulContent:
+  """Tests for the _has_meaningful_content helper function."""
+
+  def test_no_content(self):
+    """Event with no content is not meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=None,
+    )
+    assert not _has_meaningful_content(event)
+
+  def test_empty_parts(self):
+    """Event with empty parts list is not meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(role='model', parts=[]),
+    )
+    assert not _has_meaningful_content(event)
+
+  def test_only_empty_text_part(self):
+    """Event with only an empty text part is not meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model', parts=[types.Part.from_text(text='')]
+        ),
+    )
+    assert not _has_meaningful_content(event)
+
+  def test_only_whitespace_text_part(self):
+    """Event with only whitespace text is not meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model', parts=[types.Part.from_text(text='   \n  ')]
+        ),
+    )
+    assert not _has_meaningful_content(event)
+
+  def test_thought_only_parts(self):
+    """Event with only thought parts is not meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[types.Part(text='Let me think...', thought=True)],
+        ),
+    )
+    assert not _has_meaningful_content(event)
+
+  def test_text_content_is_meaningful(self):
+    """Event with non-empty text is meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[types.Part.from_text(text='Here is the answer.')],
+        ),
+    )
+    assert _has_meaningful_content(event)
+
+  def test_function_call_is_meaningful(self):
+    """Event with a function call is meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[
+                types.Part(
+                    function_call=types.FunctionCall(name='my_tool', args={})
+                )
+            ],
+        ),
+    )
+    assert _has_meaningful_content(event)
+
+  def test_function_response_is_meaningful(self):
+    """Event with a function response is meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[
+                types.Part(
+                    function_response=types.FunctionResponse(
+                        name='my_tool', response={'result': 'ok'}
+                    )
+                )
+            ],
+        ),
+    )
+    assert _has_meaningful_content(event)
+
+  def test_thought_plus_text_is_meaningful(self):
+    """Event with thought AND real text is meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[
+                types.Part(text='Thinking...', thought=True),
+                types.Part.from_text(text='The answer is 42.'),
+            ],
+        ),
+    )
+    assert _has_meaningful_content(event)
+
+  def test_inline_data_is_meaningful(self):
+    """Event with inline data is meaningful."""
+    event = Event(
+        invocation_id='test',
+        author='model',
+        content=types.Content(
+            role='model',
+            parts=[
+                types.Part(
+                    inline_data=types.Blob(
+                        mime_type='image/png', data=b'\x89PNG'
+                    )
+                )
+            ],
+        ),
+    )
+    assert _has_meaningful_content(event)
+
+
+class TestMaxEmptyResponseRetries:
+  """Verify the retry constant is sensible."""
+
+  def test_retry_limit_is_positive(self):
+    assert _MAX_EMPTY_RESPONSE_RETRIES > 0
+
+  def test_retry_limit_is_small(self):
+    """Retry limit should be small to avoid excessive re-prompts."""
+    assert _MAX_EMPTY_RESPONSE_RETRIES <= 5