Add confirmed function to next LLM call

Author: r4inee

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

@@ -39,8 +39,10 @@
 import com.google.genai.types.Part;
 import io.reactivex.rxjava3.core.Maybe;
 import io.reactivex.rxjava3.core.Single;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -103,8 +105,8 @@ public Single<RequestProcessor.RequestProcessingResult> processRequest(
         continue;
       }
 
-      Map<String, ToolConfirmation> toolsToResumeWithConfirmation = new HashMap<>();
-      Map<String, FunctionCall> toolsToResumeWithArgs = new HashMap<>();
+      final Map<String, ToolConfirmation> toolsToResumeWithConfirmation = new HashMap<>();
+      final Map<String, FunctionCall> toolsToResumeWithArgs = new HashMap<>();
 
       event.functionCalls().stream()
           .filter(
@@ -144,7 +146,35 @@ public Single<RequestProcessor.RequestProcessingResult> processRequest(
               invocationContext,
               toolsToResumeWithArgs.values(),
               ImmutableMap.copyOf(toolsToResumeWithConfirmation))
-          .map(e -> RequestProcessingResult.create(llmRequest, ImmutableList.of(e)))
+          .map(
+              responseEvent -> {
+                final List<Content> updatedContent = new ArrayList<>(llmRequest.contents());
+                final List<Part> functionCalls =
+                    toolsToResumeWithArgs.values().stream()
+                        .map(functionCall -> Part.builder().functionCall(functionCall).build())
+                        .collect(toImmutableList());
+
+                Content functionCallContent =
+                    Content.builder().role("model").parts(functionCalls).build();
+
+                // append function call to next LLM request
+                updatedContent.add(functionCallContent);
+                // append function response to next LLM request
+                updatedContent.add(
+                    Content.builder()
+                        .role("user")
+                        .parts(
+                            responseEvent.functionResponses().stream()
+                                .map(
+                                    functionResponse ->
+                                        Part.builder().functionResponse(functionResponse).build())
+                                .collect(toImmutableList()))
+                        .build());
+
+                return RequestProcessingResult.create(
+                    llmRequest.toBuilder().contents(updatedContent).build(),
+                    ImmutableList.of(responseEvent));
+              })
           .toSingle();
     }
 

core/src/test/java/com/google/adk/flows/llmflows/RequestConfirmationLlmRequestProcessorTest.java

@@ -102,11 +102,48 @@ public class RequestConfirmationLlmRequestProcessorTest {
                       .build()))
           .build();
 
+  private static final Event FUNCTION_CALL_EVENT =
+      Event.builder()
+          .author("model")
+          .content(
+              Content.builder()
+                  .role("model")
+                  .parts(
+                      Part.builder()
+                          .functionCall(
+                              FunctionCall.builder()
+                                  .id(ORIGINAL_FUNCTION_CALL_ID)
+                                  .name(ECHO_TOOL_NAME)
+                                  .args(ImmutableMap.of("say", "hello"))
+                                  .build())
+                          .build())
+                  .build())
+          .build();
+
+  private static final Event FUNCTION_RESPONSE_EVENT =
+      Event.builder()
+          .author("user")
+          .content(
+              Content.builder()
+                  .role("user")
+                  .parts(
+                      Part.builder()
+                          .functionResponse(
+                              FunctionResponse.builder()
+                                  .id(ORIGINAL_FUNCTION_CALL_ID)
+                                  .name(ECHO_TOOL_NAME)
+                                  .response(
+                                      ImmutableMap.of("result", ImmutableMap.of("say", "hello")))
+                                  .build())
+                          .build())
+                  .build())
+          .build();
+
   private static final RequestConfirmationLlmRequestProcessor processor =
       new RequestConfirmationLlmRequestProcessor();
 
   @Test
-  public void runAsync_withConfirmation_callsOriginalFunction() {
+  public void runAsync_withConfirmation_callsOriginalFunctionAndAppendsToUpdatedRequest() {
     LlmAgent agent = createAgentWithEchoTool();
     Session session =
         Session.builder("session_id")
@@ -126,6 +163,14 @@ public void runAsync_withConfirmation_callsOriginalFunction() {
     assertThat(fr.id()).hasValue(ORIGINAL_FUNCTION_CALL_ID);
     assertThat(fr.name()).hasValue(ECHO_TOOL_NAME);
     assertThat(fr.response()).hasValue(ImmutableMap.of("result", ImmutableMap.of("say", "hello")));
+    assertThat(result.updatedRequest())
+        .isEqualTo(
+            LlmRequest.builder()
+                .contents(
+                    ImmutableList.of(
+                        FUNCTION_CALL_EVENT.content().get(),
+                        FUNCTION_RESPONSE_EVENT.content().get()))
+                .build());
   }
 
   @Test