Method _preprocess_args

src/google/adk/tools/function_tool.py:106–211

Preprocess and convert function arguments before invocation. Currently handles: - Converting JSON dictionaries to Pydantic model instances where expected Future extensions could include: - Type coercion for other complex types - Validation and sanitization - Custom conversi

(self, args: dict[str, Any])

    return function_decl

  def _preprocess_args(self, args: dict[str, Any]) -> dict[str, Any]:
    """Preprocess and convert function arguments before invocation.

    Currently handles:
    - Converting JSON dictionaries to Pydantic model instances where expected

    Future extensions could include:
    - Type coercion for other complex types
    - Validation and sanitization
    - Custom conversion logic

    Args:
      args: Raw arguments from the LLM tool call

    Returns:
      Processed arguments ready for function invocation
    """
    signature = inspect.signature(self.func)
    converted_args = args.copy()
    try:
      type_hints = get_type_hints(self.func)
    except (TypeError, NameError):
      # NameError: unresolved forward refs (e.g. recursive type aliases).
      # TypeError: non-function callables.
      if hasattr(self.func, '__call__'):
        try:
          type_hints = get_type_hints(self.func.__call__)
        except (TypeError, NameError):
          type_hints = {}
      else:
        type_hints = {}

    for param_name, param in signature.parameters.items():
      if param_name in args:
        target_type = type_hints.get(param_name, param.annotation)
        if target_type != inspect.Parameter.empty:

          # Handle Optional[PydanticModel] types
          if get_origin(param.annotation) is Union:
            union_args = get_args(param.annotation)
            # Find the non-None type in Optional[T] (which is Union[T, None])
            non_none_types = [
                arg for arg in union_args if arg is not type(None)
            ]
            if len(non_none_types) == 1:
              target_type = non_none_types[0]
            elif len(non_none_types) > 1 and all(
                inspect.isclass(t) and issubclass(t, pydantic.BaseModel)
                for t in non_none_types
            ):
              if args[param_name] is None or isinstance(
                  args[param_name], tuple(non_none_types)
              ):
                continue
              try:
                converted_args[param_name] = pydantic.TypeAdapter(
                    param.annotation
                ).validate_python(args[param_name])