Merge branch 'main' into fix/pydantic-v2-swagger-ui

Author: mmphego

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

@@ -19,7 +19,6 @@
 from typing import AsyncGenerator
 from typing import TYPE_CHECKING
 
-from google.genai import _transformers
 from typing_extensions import override
 
 from ...agents.readonly_context import ReadonlyContext
@@ -85,6 +84,8 @@ async def run_async(
 
     # Handle static_instruction - add via append_instructions
     if agent.static_instruction:
+      from google.genai import _transformers
+
       # Convert ContentUnion to Content using genai transformer
       static_content = _transformers.t_content(agent.static_instruction)
       llm_request.append_instructions(static_content)

src/google/adk/models/apigee_llm.py

@@ -18,21 +18,22 @@
 from functools import cached_property
 import logging
 import os
-import re
 from typing import Optional
 from typing import TYPE_CHECKING
 
 from google.adk import version as adk_version
-from google.genai import Client
 from google.genai import types
 from typing_extensions import override
 
 from ..utils.env_utils import is_env_enabled
 from .google_llm import Gemini
 
 if TYPE_CHECKING:
+  from google.genai import Client
+
   from .llm_request import LlmRequest
 
+
 logger = logging.getLogger('google_adk.' + __name__)
 
 _APIGEE_PROXY_URL_ENV_VARIABLE_NAME = 'APIGEE_PROXY_URL'
@@ -137,6 +138,7 @@ def api_client(self) -> Client:
     Returns:
       The api client.
     """
+    from google.genai import Client
 
     kwargs_for_http_options = {}
     if self._api_version:

src/google/adk/models/gemini_context_cache_manager.py

@@ -21,8 +21,8 @@
 import logging
 import time
 from typing import Optional
+from typing import TYPE_CHECKING
 
-from google.genai import Client
 from google.genai import types
 
 from ..utils.feature_decorator import experimental
@@ -32,6 +32,9 @@
 
 logger = logging.getLogger("google_adk." + __name__)
 
+if TYPE_CHECKING:
+  from google.genai import Client
+
 
 @experimental
 class GeminiContextCacheManager:

src/google/adk/models/gemini_llm_connection.py

@@ -18,7 +18,6 @@
 from typing import AsyncGenerator
 from typing import Union
 
-from google.genai import live
 from google.genai import types
 
 from ..utils.context_utils import Aclosing
@@ -28,6 +27,10 @@
 logger = logging.getLogger('google_adk.' + __name__)
 
 RealtimeInput = Union[types.Blob, types.ActivityStart, types.ActivityEnd]
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+  from google.genai import live
 
 
 class GeminiLlmConnection(BaseLlmConnection):
@@ -58,6 +61,7 @@ async def send_history(self, history: list[types.Content]):
         for content in history
         if content.parts and content.parts[0].text
     ]
+    logger.debug('Sending history to live connection: %s', contents)
 
     if contents:
       await self._gemini_session.send(

src/google/adk/models/google_llm.py

@@ -27,7 +27,6 @@
 from typing import TYPE_CHECKING
 from typing import Union
 
-from google.genai import Client
 from google.genai import types
 from typing_extensions import override
 
@@ -41,6 +40,8 @@
 from .llm_response import LlmResponse
 
 if TYPE_CHECKING:
+  from google.genai import Client
+
   from .llm_request import LlmRequest
 
 logger = logging.getLogger('google_adk.' + __name__)
@@ -200,6 +201,8 @@ def api_client(self) -> Client:
     Returns:
       The api client.
     """
+    from google.genai import Client
+
     return Client(
         http_options=types.HttpOptions(
             headers=self._tracking_headers,
@@ -239,6 +242,8 @@ def _live_api_version(self) -> str:
 
   @cached_property
   def _live_api_client(self) -> Client:
+    from google.genai import Client
+
     return Client(
         http_options=types.HttpOptions(
             headers=self._tracking_headers, api_version=self._live_api_version
@@ -283,6 +288,7 @@ async def connect(self, llm_request: LlmRequest) -> BaseLlmConnection:
     llm_request.live_connect_config.tools = llm_request.config.tools
     logger.info('Connecting to live for model: %s', llm_request.model)
     logger.debug('Connecting to live with llm_request:%s', llm_request)
+    logger.debug('Live connect config: %s', llm_request.live_connect_config)
     async with self._live_api_client.aio.live.connect(
         model=llm_request.model, config=llm_request.live_connect_config
     ) as live_session:

src/google/adk/tools/_automatic_function_calling_util.py

@@ -296,20 +296,55 @@ def from_function_with_options(
 ) -> 'types.FunctionDeclaration':
 
   parameters_properties = {}
-  for name, param in inspect.signature(func).parameters.items():
-    if param.kind in (
-        inspect.Parameter.POSITIONAL_OR_KEYWORD,
-        inspect.Parameter.KEYWORD_ONLY,
-        inspect.Parameter.POSITIONAL_ONLY,
-    ):
-      # This snippet catches the case when type hints are stored as strings
-      if isinstance(param.annotation, str):
-        param = param.replace(annotation=typing.get_type_hints(func)[name])
-
-      schema = _function_parameter_parse_util._parse_schema_from_parameter(
-          variant, param, func.__name__
-      )
-      parameters_properties[name] = schema
+  parameters_json_schema = {}
+  annotation_under_future = typing.get_type_hints(func)
+  try:
+    for name, param in inspect.signature(func).parameters.items():
+      if param.kind in (
+          inspect.Parameter.POSITIONAL_OR_KEYWORD,
+          inspect.Parameter.KEYWORD_ONLY,
+          inspect.Parameter.POSITIONAL_ONLY,
+      ):
+        param = _function_parameter_parse_util._handle_params_as_deferred_annotations(
+            param, annotation_under_future, name
+        )
+
+        schema = _function_parameter_parse_util._parse_schema_from_parameter(
+            variant, param, func.__name__
+        )
+        parameters_properties[name] = schema
+  except ValueError:
+    # If the function has complex parameter types that fail in _parse_schema_from_parameter,
+    # we try to generate a json schema for the parameter using pydantic.TypeAdapter.
+    parameters_properties = {}
+    for name, param in inspect.signature(func).parameters.items():
+      if param.kind in (
+          inspect.Parameter.POSITIONAL_OR_KEYWORD,
+          inspect.Parameter.KEYWORD_ONLY,
+          inspect.Parameter.POSITIONAL_ONLY,
+      ):
+        try:
+          if param.annotation == inspect.Parameter.empty:
+            param = param.replace(annotation=Any)
+
+          param = _function_parameter_parse_util._handle_params_as_deferred_annotations(
+              param, annotation_under_future, name
+          )
+
+          _function_parameter_parse_util._raise_for_invalid_enum_value(param)
+
+          json_schema_dict = _function_parameter_parse_util._generate_json_schema_for_parameter(
+              param
+          )
+
+          parameters_json_schema[name] = types.Schema.model_validate(
+              json_schema_dict
+          )
+        except Exception as e:
+          _function_parameter_parse_util._raise_for_unsupported_param(
+              param, func.__name__, e
+          )
+
   declaration = types.FunctionDeclaration(
       name=func.__name__,
       description=func.__doc__,
@@ -324,6 +359,12 @@ def from_function_with_options(
             declaration.parameters
         )
     )
+  elif parameters_json_schema:
+    declaration.parameters = types.Schema(
+        type='OBJECT',
+        properties=parameters_json_schema,
+    )
+
   if variant == GoogleLLMVariant.GEMINI_API:
     return declaration
 
@@ -372,17 +413,35 @@ def from_function_with_options(
       inspect.Parameter.POSITIONAL_OR_KEYWORD,
       annotation=return_annotation,
   )
-  # This snippet catches the case when type hints are stored as strings
   if isinstance(return_value.annotation, str):
     return_value = return_value.replace(
         annotation=typing.get_type_hints(func)['return']
     )
 
-  declaration.response = (
-      _function_parameter_parse_util._parse_schema_from_parameter(
-          variant,
-          return_value,
-          func.__name__,
+  response_schema: Optional[types.Schema] = None
+  response_json_schema: Optional[Union[Dict[str, Any], types.Schema]] = None
+  try:
+    response_schema = (
+        _function_parameter_parse_util._parse_schema_from_parameter(
+            variant,
+            return_value,
+            func.__name__,
+        )
+    )
+  except ValueError:
+    try:
+      response_json_schema = (
+          _function_parameter_parse_util._generate_json_schema_for_parameter(
+              return_value
+          )
       )
-  )
+      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
+      )
+  if response_schema:
+    declaration.response = response_schema
+  elif response_json_schema:
+    declaration.response = response_json_schema
   return declaration

src/google/adk/tools/_function_parameter_parse_util.py

@@ -49,6 +49,91 @@
 logger = logging.getLogger('google_adk.' + __name__)
 
 
+def _handle_params_as_deferred_annotations(
+    param: inspect.Parameter, annotation_under_future: dict[str, Any], name: str
+) -> inspect.Parameter:
+  """Catches the case when type hints are stored as strings."""
+  if isinstance(param.annotation, str):
+    param = param.replace(annotation=annotation_under_future[name])
+  return param
+
+
+def _add_unevaluated_items_to_fixed_len_tuple_schema(
+    json_schema: dict[str, Any],
+) -> dict[str, Any]:
+  """Adds 'unevaluatedItems': False to schemas for fixed-length tuples.
+
+  For example, the schema for a parameter of type `tuple[float, float]` would
+  be:
+  {
+      "type": "array",
+      "prefixItems": [
+          {
+              "type": "number"
+          },
+          {
+              "type": "number"
+          },
+      ],
+      "minItems": 2,
+      "maxItems": 2,
+      "unevaluatedItems": False
+  }
+
+  """
+  if (
+      json_schema.get('maxItems')
+      and (
+          json_schema.get('prefixItems')
+          and len(json_schema['prefixItems']) == json_schema['maxItems']
+      )
+      and json_schema.get('type') == 'array'
+  ):
+    json_schema['unevaluatedItems'] = False
+  return json_schema
+
+
+def _raise_for_unsupported_param(
+    param: inspect.Parameter,
+    func_name: str,
+    exception: Exception,
+) -> None:
+  raise ValueError(
+      f'Failed to parse the parameter {param} of function {func_name} for'
+      ' automatic function calling.Automatic function calling works best with'
+      ' simpler function signature schema, consider manually parsing your'
+      f' function declaration for function {func_name}.'
+  ) from exception
+
+
+def _raise_for_invalid_enum_value(param: inspect.Parameter):
+  """Raises an error if the default value is not a valid enum value."""
+  if inspect.isclass(param.annotation) and issubclass(param.annotation, Enum):
+    if param.default is not inspect.Parameter.empty and param.default not in [
+        e.value for e in param.annotation
+    ]:
+      raise ValueError(
+          f'Default value {param.default} is not a valid enum value for'
+          f' {param.annotation}.'
+      )
+
+
+def _generate_json_schema_for_parameter(
+    param: inspect.Parameter,
+) -> dict[str, Any]:
+  """Generates a JSON schema for a parameter using pydantic.TypeAdapter."""
+
+  param_schema_adapter = pydantic.TypeAdapter(
+      param.annotation,
+      config=pydantic.ConfigDict(arbitrary_types_allowed=True),
+  )
+  json_schema_dict = param_schema_adapter.json_schema()
+  json_schema_dict = _add_unevaluated_items_to_fixed_len_tuple_schema(
+      json_schema_dict
+  )
+  return json_schema_dict
+
+
 def _is_builtin_primitive_or_compound(
     annotation: inspect.Parameter.annotation,
 ) -> bool: