feat: Enable FunctionTools to be created for methods that return a Single.

PiperOrigin-RevId: 775889299

Author: google-genai-bot

core/src/main/java/com/google/adk/tools/FunctionCallingUtils.java

@@ -73,7 +73,8 @@ static FunctionDeclaration buildFunctionDeclaration(Method func, List<String> ig
       if (returnType instanceof ParameterizedType) {
         ParameterizedType parameterizedReturnType = (ParameterizedType) returnType;
         String returnTypeName = ((Class<?>) parameterizedReturnType.getRawType()).getName();
-        if (returnTypeName.equals("io.reactivex.rxjava3.core.Maybe")) {
+        if (returnTypeName.equals("io.reactivex.rxjava3.core.Maybe")
+            || returnTypeName.equals("io.reactivex.rxjava3.core.Single")) {
           returnType = parameterizedReturnType.getActualTypeArguments()[0];
           if (returnType instanceof ParameterizedType) {
             ParameterizedType maybeParameterizedType = (ParameterizedType) returnType;
@@ -86,7 +87,8 @@ static FunctionDeclaration buildFunctionDeclaration(Method func, List<String> ig
         }
       }
       throw new IllegalArgumentException(
-          "Return type should be Map or Maybe<Map>, but it was " + realReturnType.getTypeName());
+          "Return type should be Map or Maybe<Map> or Single<Map>, but it was "
+              + realReturnType.getTypeName());
     }
     return builder.build();
   }

core/src/main/java/com/google/adk/tools/FunctionTool.java

@@ -197,6 +197,8 @@ private Maybe<Map<String, Object>> call(Map<String, Object> args, ToolContext to
       return Maybe.empty();
     } else if (result instanceof Maybe) {
       return (Maybe<Map<String, Object>>) result;
+    } else if (result instanceof Single) {
+      return ((Single<Map<String, Object>>) result).toMaybe();
     } else {
       return Maybe.just((Map<String, Object>) result);
     }

core/src/test/java/com/google/adk/tools/FunctionToolTest.java

@@ -26,6 +26,7 @@
 import com.google.genai.types.FunctionDeclaration;
 import com.google.genai.types.Schema;
 import io.reactivex.rxjava3.core.Maybe;
+import io.reactivex.rxjava3.core.Single;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.List;
@@ -343,6 +344,24 @@ public void create_withMaybeStringReturnType() {
         () -> FunctionTool.create(Functions.class, "returnsMaybeString"));
   }
 
+  @Test
+  public void create_withSingleMapReturnType() {
+    FunctionTool tool = FunctionTool.create(Functions.class, "returnsSingleMap");
+
+    assertThat(tool).isNotNull();
+    assertThat(tool.declaration().get().response())
+        .hasValue(Schema.builder().type("OBJECT").build());
+  }
+
+  @Test
+  public void call_withSingleMapReturnType() throws Exception {
+    FunctionTool tool = FunctionTool.create(Functions.class, "returnsSingleMap");
+
+    Map<String, Object> result = tool.runAsync(new HashMap<>(), null).blockingGet();
+
+    assertThat(result).containsExactly("key", "value");
+  }
+
   @Test
   public void call_nonStaticWithAllSupportedParameterTypes() throws Exception {
     Functions functions = new Functions();
@@ -463,6 +482,10 @@ public static Maybe<String> returnsMaybeString() {
       return Maybe.just("not supported");
     }
 
+    public static Single<Map<String, Object>> returnsSingleMap() {
+      return Single.just(ImmutableMap.of("key", "value"));
+    }
+
     public void nonStaticVoidReturnWithoutSchema() {}
 
     public ImmutableMap<String, Object> nonStaticReturnAllSupportedParametersAsMap(