fix: surface MALFORMED_FUNCTION_CALL so on_model_error can recover

A Gemini turn that finishes with MALFORMED_FUNCTION_CALL yields a
response with an error code but no actionable content. The flow builds a
content-free event with no function call and the agent loop ends,
silently terminating the invocation mid-run instead of surfacing an
error.

Raise on a content-free MALFORMED_FUNCTION_CALL response so it flows
through the existing on_model_error callbacks, mirroring the LiteLlm
malformed-argument path (google#5008). Callbacks can now recover; without one
the run fails loudly instead of stalling.

Co-authored-by: George Weale <gweale@google.com>
PiperOrigin-RevId: 932585954

Author: GWeale

src/google/adk/errors/malformed_function_call_error.py

@@ -0,0 +1,26 @@
+# 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.
+
+from __future__ import annotations
+
+
+class MalformedFunctionCallError(ValueError):
+  """The model returned a malformed function call with no usable content.
+
+  Raised by the model layer when a turn finishes with
+  ``FinishReason.MALFORMED_FUNCTION_CALL`` and carries no content the agent can
+  act on. Subclasses ``ValueError`` so existing handlers keep working, while
+  ``on_model_error`` callbacks can match this specific case to recover (for
+  example, by retrying the turn).
+  """

src/google/adk/models/google_llm.py

@@ -33,6 +33,7 @@
 from google.genai.errors import ClientError
 from typing_extensions import override
 
+from ..errors.malformed_function_call_error import MalformedFunctionCallError
 from ..utils._google_client_headers import get_tracking_headers
 from ..utils._google_client_headers import merge_tracking_headers
 from ..utils.context_utils import Aclosing
@@ -62,6 +63,27 @@
 """
 
 
+def _raise_for_malformed_function_call(llm_response: LlmResponse) -> None:
+  """Raises when the model returned a malformed function call with no content.
+
+  A ``MALFORMED_FUNCTION_CALL`` finish reason yields a response that carries an
+  error code but nothing the agent can act on. Left alone it builds a
+  content-free event with no function call, which silently ends the invocation.
+  Raising routes it through the on_model_error callbacks so they can recover,
+  mirroring the LiteLlm malformed-arguments path. The error subclasses
+  ``ValueError`` so callbacks can match this case specifically without breaking
+  existing handlers.
+  """
+  if (
+      llm_response.finish_reason == types.FinishReason.MALFORMED_FUNCTION_CALL
+      and not (llm_response.content and llm_response.content.parts)
+  ):
+    raise MalformedFunctionCallError(
+        llm_response.error_message
+        or 'Model returned a malformed function call.'
+    )
+
+
 class _ResourceExhaustedError(ClientError):
   """Represents a resources exhausted error received from the Model."""
 
@@ -258,6 +280,7 @@ async def generate_content_async(
                 aggregator.process_response(response)
             ) as aggregator_gen:
               async for llm_response in aggregator_gen:
+                _raise_for_malformed_function_call(llm_response)
                 yield llm_response
         if (close_result := aggregator.close()) is not None:
           # Populate cache metadata in the final aggregated response for
@@ -266,6 +289,7 @@ async def generate_content_async(
             cache_manager.populate_cache_metadata_in_response(
                 close_result, cache_metadata
             )
+          _raise_for_malformed_function_call(close_result)
           yield close_result
 
       else:
@@ -283,6 +307,7 @@ async def generate_content_async(
           cache_manager.populate_cache_metadata_in_response(
               llm_response, cache_metadata
           )
+        _raise_for_malformed_function_call(llm_response)
         yield llm_response
     except ClientError as ce:
       if ce.code == 429:

tests/unittests/models/test_google_llm.py

@@ -21,6 +21,7 @@
 
 from google.adk import version as adk_version
 from google.adk.agents.context_cache_config import ContextCacheConfig
+from google.adk.errors.malformed_function_call_error import MalformedFunctionCallError
 from google.adk.models.cache_metadata import CacheMetadata
 from google.adk.models.gemini_llm_connection import GeminiLlmConnection
 from google.adk.models.google_llm import _build_function_declaration_log
@@ -322,6 +323,70 @@ async def mock_coro():
     mock_client.aio.models.generate_content.assert_called_once()
 
 
+@pytest.mark.asyncio
+async def test_generate_content_async_malformed_function_call_raises(
+    gemini_llm, llm_request
+):
+  malformed_response = types.GenerateContentResponse(
+      candidates=[
+          types.Candidate(
+              content=None,
+              finish_reason=types.FinishReason.MALFORMED_FUNCTION_CALL,
+              finish_message="Malformed function call: print(default_api.f(x=",
+          )
+      ]
+  )
+  with mock.patch.object(gemini_llm, "api_client") as mock_client:
+
+    async def mock_coro():
+      return malformed_response
+
+    mock_client.aio.models.generate_content.return_value = mock_coro()
+
+    with pytest.raises(
+        MalformedFunctionCallError, match="alformed function call"
+    ):
+      _ = [
+          resp
+          async for resp in gemini_llm.generate_content_async(
+              llm_request, stream=False
+          )
+      ]
+
+
+@pytest.mark.asyncio
+async def test_generate_content_async_stream_malformed_function_call_raises(
+    gemini_llm, llm_request
+):
+  mock_responses = [
+      types.GenerateContentResponse(
+          candidates=[
+              types.Candidate(
+                  content=None,
+                  finish_reason=types.FinishReason.MALFORMED_FUNCTION_CALL,
+                  finish_message="Malformed function call",
+              )
+          ]
+      ),
+  ]
+  with mock.patch.object(gemini_llm, "api_client") as mock_client:
+
+    async def mock_coro():
+      return MockAsyncIterator(mock_responses)
+
+    mock_client.aio.models.generate_content_stream.return_value = mock_coro()
+
+    with pytest.raises(
+        MalformedFunctionCallError, match="alformed function call"
+    ):
+      _ = [
+          resp
+          async for resp in gemini_llm.generate_content_async(
+              llm_request, stream=True
+          )
+      ]
+
+
 @pytest.mark.asyncio
 async def test_generate_content_async_stream(gemini_llm, llm_request):
   with mock.patch.object(gemini_llm, "api_client") as mock_client: