feat: Support configuring tool execution mode in RunConfig

PiperOrigin-RevId: 837140637

Author: google-genai-bot

core/src/main/java/com/google/adk/flows/llmflows/Functions.java

@@ -47,6 +47,7 @@
 import io.reactivex.rxjava3.core.Maybe;
 import io.reactivex.rxjava3.core.Single;
 import io.reactivex.rxjava3.disposables.Disposable;
+import io.reactivex.rxjava3.functions.Function;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -137,27 +138,28 @@ public static Maybe<Event> handleFunctionCalls(
       Map<String, ToolConfirmation> toolConfirmations) {
     ImmutableList<FunctionCall> functionCalls = functionCallEvent.functionCalls();
 
-    List<Maybe<Event>> functionResponseEvents = new ArrayList<>();
-
     for (FunctionCall functionCall : functionCalls) {
       if (!tools.containsKey(functionCall.name().get())) {
         throw new VerifyException("Tool not found: " + functionCall.name().get());
       }
-      BaseTool tool = tools.get(functionCall.name().get());
-      ToolContext toolContext =
-          ToolContext.builder(invocationContext)
-              .functionCallId(functionCall.id().orElse(""))
-              .toolConfirmation(toolConfirmations.get(functionCall.id().orElse(null)))
-              .build();
+    }
+
+    Function<FunctionCall, Maybe<Event>> functionCallMapper =
+        functionCall -> {
+          BaseTool tool = tools.get(functionCall.name().get());
+          ToolContext toolContext =
+              ToolContext.builder(invocationContext)
+                  .functionCallId(functionCall.id().orElse(""))
+                  .toolConfirmation(toolConfirmations.get(functionCall.id().orElse(null)))
+                  .build();
 
-      Map<String, Object> functionArgs = functionCall.args().orElse(ImmutableMap.of());
+          Map<String, Object> functionArgs = functionCall.args().orElse(ImmutableMap.of());
 
-      Maybe<Map<String, Object>> maybeFunctionResult =
-          maybeInvokeBeforeToolCall(invocationContext, tool, functionArgs, toolContext)
-              .switchIfEmpty(Maybe.defer(() -> callTool(tool, functionArgs, toolContext)));
+          Maybe<Map<String, Object>> maybeFunctionResult =
+              maybeInvokeBeforeToolCall(invocationContext, tool, functionArgs, toolContext)
+                  .switchIfEmpty(Maybe.defer(() -> callTool(tool, functionArgs, toolContext)));
 
-      Maybe<Event> maybeFunctionResponseEvent =
-          maybeFunctionResult
+          return maybeFunctionResult
               .map(Optional::of)
               .defaultIfEmpty(Optional.empty())
               .onErrorResumeNext(
@@ -195,15 +197,15 @@ public static Maybe<Event> handleFunctionCalls(
                               return Maybe.just(functionResponseEvent);
                             });
                   });
-
-      functionResponseEvents.add(maybeFunctionResponseEvent);
-    }
+        };
 
     Flowable<Event> functionResponseEventsFlowable;
     if (invocationContext.runConfig().toolExecutionMode() == ToolExecutionMode.SEQUENTIAL) {
-      functionResponseEventsFlowable = Maybe.concat(functionResponseEvents);
+      functionResponseEventsFlowable =
+          Flowable.fromIterable(functionCalls).concatMapMaybe(functionCallMapper);
     } else {
-      functionResponseEventsFlowable = Maybe.merge(functionResponseEvents);
+      functionResponseEventsFlowable =
+          Flowable.fromIterable(functionCalls).flatMapMaybe(functionCallMapper);
     }
     return functionResponseEventsFlowable
         .toList()
@@ -240,29 +242,35 @@ public static Maybe<Event> handleFunctionCalls(
   public static Maybe<Event> handleFunctionCallsLive(
       InvocationContext invocationContext, Event functionCallEvent, Map<String, BaseTool> tools) {
     ImmutableList<FunctionCall> functionCalls = functionCallEvent.functionCalls();
-    List<Maybe<Event>> responseEvents = new ArrayList<>();
 
     for (FunctionCall functionCall : functionCalls) {
       if (!tools.containsKey(functionCall.name().get())) {
         throw new VerifyException("Tool not found: " + functionCall.name().get());
       }
-      BaseTool tool = tools.get(functionCall.name().get());
-      ToolContext toolContext =
-          ToolContext.builder(invocationContext)
-              .functionCallId(functionCall.id().orElse(""))
-              .build();
-      Map<String, Object> functionArgs = functionCall.args().orElse(new HashMap<>());
-
-      Maybe<Map<String, Object>> maybeFunctionResult =
-          maybeInvokeBeforeToolCall(invocationContext, tool, functionArgs, toolContext)
-              .switchIfEmpty(
-                  Maybe.defer(
-                      () ->
-                          processFunctionLive(
-                              invocationContext, tool, toolContext, functionCall, functionArgs)));
-
-      Maybe<Event> maybeFunctionResponseEvent =
-          maybeFunctionResult
+    }
+
+    Function<FunctionCall, Maybe<Event>> functionCallMapper =
+        functionCall -> {
+          BaseTool tool = tools.get(functionCall.name().get());
+          ToolContext toolContext =
+              ToolContext.builder(invocationContext)
+                  .functionCallId(functionCall.id().orElse(""))
+                  .build();
+          Map<String, Object> functionArgs = functionCall.args().orElse(new HashMap<>());
+
+          Maybe<Map<String, Object>> maybeFunctionResult =
+              maybeInvokeBeforeToolCall(invocationContext, tool, functionArgs, toolContext)
+                  .switchIfEmpty(
+                      Maybe.defer(
+                          () ->
+                              processFunctionLive(
+                                  invocationContext,
+                                  tool,
+                                  toolContext,
+                                  functionCall,
+                                  functionArgs)));
+
+          return maybeFunctionResult
               .map(Optional::of)
               .defaultIfEmpty(Optional.empty())
               .onErrorResumeNext(
@@ -300,15 +308,19 @@ public static Maybe<Event> handleFunctionCallsLive(
                               return Maybe.just(functionResponseEvent);
                             });
                   });
-      responseEvents.add(maybeFunctionResponseEvent);
-    }
+        };
 
     Flowable<Event> responseEventsFlowable;
+
     if (invocationContext.runConfig().toolExecutionMode() == ToolExecutionMode.SEQUENTIAL) {
-      responseEventsFlowable = Maybe.concat(responseEvents);
+      responseEventsFlowable =
+          Flowable.fromIterable(functionCalls).concatMapMaybe(functionCallMapper);
+
     } else {
-      responseEventsFlowable = Maybe.merge(responseEvents);
+      responseEventsFlowable =
+          Flowable.fromIterable(functionCalls).flatMapMaybe(functionCallMapper);
     }
+
     return responseEventsFlowable
         .toList()
         .flatMapMaybe(