fix: stop automatic function calling from failing on Vertex AI return types

Vertex AI raised an error whenever it could not derive a response schema
for a tool's return type, so a tool that worked fine on the Gemini API
crashed on Vertex AI. The Gemini API path simply skips the return-type
schema, so the two backends diverged. Broaden the return-type schema
derivation to degrade the same way: on failure, log a warning and omit
the response schema, deferring validation to the model API instead of
rejecting an otherwise valid tool.

Close #3543

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

Author: GWeale

src/google/adk/tools/_automatic_function_calling_util.py

@@ -16,6 +16,7 @@
 
 import collections.abc
 import inspect
+import logging
 from types import FunctionType
 import typing
 from typing import Any
@@ -39,6 +40,8 @@
 from ..utils.variant_utils import GoogleLLMVariant
 from ._gemini_schema_util import _sanitize_schema_formats_for_gemini
 
+logger = logging.getLogger('google_adk.' + __name__)
+
 _py_type_2_schema_type = {
     'str': types.Type.STRING,
     'int': types.Type.INTEGER,
@@ -486,7 +489,9 @@ def from_function_with_options(
             func.__name__,
         )
     )
-  except ValueError:
+  # Intentionally broad: schema derivation can raise non-ValueError types
+  # (newer Python/pydantic); any failure degrades with a warning below.
+  except Exception as primary_error:
     try:
       response_json_schema = (
           _function_parameter_parse_util._generate_json_schema_for_parameter(
@@ -495,8 +500,14 @@ def from_function_with_options(
       )
       response_json_schema = types.Schema.model_validate(response_json_schema)
     except Exception as e:
-      _function_parameter_parse_util._raise_for_unsupported_param(
-          return_value, func.__name__, e
+      # Degrade like GEMINI_API instead of rejecting a valid return type: omit
+      # the response schema and defer validation to the model API.
+      logger.warning(
+          'Could not generate a response schema for the return type of %s;'
+          ' omitting it. Fallback error: %s. Original error: %s',
+          func.__name__,
+          e,
+          primary_error,
       )
   if response_schema:
     declaration.response = response_schema

tests/unittests/tools/test_from_function_with_options.py

@@ -535,3 +535,120 @@ def my_tool(param: Any = 'default_string') -> str:
   assert declaration.parameters.properties['param'].default == 'default_string'
   # Any type maps to None (no type) in schema
   assert declaration.parameters.properties['param'].type is None
+
+
+class _UnserializableReturn:
+  """A plain class that has no genai/JSON schema representation."""
+
+
+def test_from_function_with_options_unserializable_return_vertex_degrades_gracefully():
+  """VERTEX_AI omits the response schema instead of raising when it can't be derived."""
+
+  def test_function(param: str) -> _UnserializableReturn:
+    """A function whose return type cannot be turned into a schema."""
+    return _UnserializableReturn()
+
+  declaration = _automatic_function_calling_util.from_function_with_options(
+      test_function, GoogleLLMVariant.VERTEX_AI
+  )
+
+  assert declaration.name == 'test_function'
+  # Parameters are still populated; only the return schema is dropped.
+  assert declaration.parameters.type == 'OBJECT'
+  assert declaration.parameters.properties['param'].type == 'STRING'
+  assert declaration.response is None
+
+
+def test_from_function_with_options_logs_warning_on_return_schema_failure(
+    caplog,
+):
+  """A warning naming the function is emitted when the return schema is dropped."""
+
+  def test_function(param: str) -> _UnserializableReturn:
+    """A function whose return type cannot be turned into a schema."""
+    return _UnserializableReturn()
+
+  with caplog.at_level(
+      'WARNING',
+      logger='google_adk.google.adk.tools._automatic_function_calling_util',
+  ):
+    _automatic_function_calling_util.from_function_with_options(
+        test_function, GoogleLLMVariant.VERTEX_AI
+    )
+
+  warnings = [r for r in caplog.records if r.levelname == 'WARNING']
+  assert len(warnings) == 1
+  assert 'test_function' in warnings[0].getMessage()
+
+
+def test_from_function_with_options_valid_pydantic_return_still_gets_schema_vertex():
+  """A serializable pydantic return type keeps producing a response schema."""
+
+  class MyModel(pydantic.BaseModel):
+    result: str
+
+  def test_function(param: str) -> MyModel:
+    """A function that returns a valid pydantic model."""
+    return MyModel(result=param)
+
+  declaration = _automatic_function_calling_util.from_function_with_options(
+      test_function, GoogleLLMVariant.VERTEX_AI
+  )
+
+  assert declaration.name == 'test_function'
+  assert declaration.response is not None
+  assert declaration.response.type == types.Type.OBJECT
+
+
+def test_from_function_with_options_non_value_error_return_degrades_gracefully(
+    monkeypatch,
+):
+  """A non-ValueError from schema parsing is caught (not propagated) and degrades."""
+
+  parse_util = _automatic_function_calling_util._function_parameter_parse_util
+  original_parse = parse_util._parse_schema_from_parameter
+
+  def _raise_type_error_for_return(variant, param, func_name):
+    # Only the return-schema parse should raise; leave parameter parsing intact.
+    if param.name == 'return_value':
+      raise TypeError('simulated non-ValueError from schema parsing')
+    return original_parse(variant, param, func_name)
+
+  monkeypatch.setattr(
+      parse_util,
+      '_parse_schema_from_parameter',
+      _raise_type_error_for_return,
+  )
+
+  def test_function(param: str) -> _UnserializableReturn:
+    """A function whose return schema parsing raises a non-ValueError."""
+    return _UnserializableReturn()
+
+  declaration = _automatic_function_calling_util.from_function_with_options(
+      test_function, GoogleLLMVariant.VERTEX_AI
+  )
+
+  assert declaration.name == 'test_function'
+  assert declaration.response is None
+
+
+def test_from_function_with_options_warning_includes_original_error(caplog):
+  """The warning names both the fallback and the original parsing error."""
+
+  def test_function(param: str) -> _UnserializableReturn:
+    """A function whose return type cannot be turned into a schema."""
+    return _UnserializableReturn()
+
+  with caplog.at_level(
+      'WARNING',
+      logger='google_adk.google.adk.tools._automatic_function_calling_util',
+  ):
+    _automatic_function_calling_util.from_function_with_options(
+        test_function, GoogleLLMVariant.VERTEX_AI
+    )
+
+  warnings = [r for r in caplog.records if r.levelname == 'WARNING']
+  assert len(warnings) == 1
+  message = warnings[0].getMessage()
+  assert 'Fallback error:' in message
+  assert 'Original error:' in message