Merge pull request #1534 from innoprej:fix/confirmation-scan-last-user-turn

PiperOrigin-RevId: 994343603

Author: copybara-github

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

@@ -82,12 +82,7 @@ public Single<RequestProcessor.RequestProcessingResult> processRequest(
     ImmutableMap<String, AuthoredFunctionCall> functionCallsById =
         functionCallsById(events, agentName);
     ImmutableSet<String> confirmationRequestedIds = confirmationRequestedIds(events);
-    // A tool has been confirmed, but it might already have been executed by a subsequent processor
-    // or in a subsequent turn: such calls have a function response after the user confirmation
-    // event. This is applied before the resumability check rather than after, because
-    // findMostRecentConfirmations re-matches the same stale user event on every later LLM call, so
-    // a settled confirmation would otherwise be re-examined - and re-logged - for the rest of the
-    // session.
+    // Calls this agent already re-ran since the approval; skipped before validation, not re-logged.
     //
     // Only responses this agent produced count. A peer event landing after the approval that
     // reuses the pending call's ID would otherwise convince this scan the tool had already run,
@@ -167,11 +162,10 @@ public Single<RequestProcessor.RequestProcessingResult> processRequest(
 
   private static Optional<ConfirmationResult> findMostRecentConfirmations(
       ImmutableList<Event> events) {
-    // Search backwards for the most recent user event that contains request confirmation
-    // function responses.
+    // As in ADK Python, only the most recent user event can answer a pending confirmation.
     for (int i = events.size() - 1; i >= 0; i--) {
       Event event = events.get(i);
-      if (!Objects.equals(event.author(), Role.USER) || event.functionResponses().isEmpty()) {
+      if (!Objects.equals(event.author(), Role.USER)) {
         continue;
       }
 
@@ -186,9 +180,9 @@ private static Optional<ConfirmationResult> findMostRecentConfirmations(
               .map(RequestConfirmationLlmRequestProcessor::maybeCreateToolConfirmationEntry)
               .flatMap(Optional::stream)
               .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
-      if (!confirmationsInEvent.isEmpty()) {
-        return Optional.of(new ConfirmationResult(confirmationsInEvent, i));
-      }
+      return confirmationsInEvent.isEmpty()
+          ? Optional.empty()
+          : Optional.of(new ConfirmationResult(confirmationsInEvent, i));
     }
     return Optional.empty();
   }

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

@@ -32,6 +32,7 @@
 import com.google.adk.plugins.PluginManager;
 import com.google.adk.sessions.InMemorySessionService;
 import com.google.adk.sessions.Session;
+import com.google.adk.summarizer.LlmEventSummarizer;
 import com.google.adk.testing.TestLlm;
 import com.google.adk.testing.TestUtils.EchoTool;
 import com.google.common.collect.ImmutableList;
@@ -208,6 +209,101 @@ public void runAsync_noEvents_empty() {
         .isEmpty();
   }
 
+  @Test
+  public void runAsync_compactionAfterApproval_doesNotCallOriginalFunction() {
+    LlmAgent agent = createAgentWithEchoTool();
+    // The summarizer's event is user-authored, so it ends the scan as in ADK Python.
+    Event compactionEvent =
+        new LlmEventSummarizer(
+                createTestLlm(createLlmResponse(Content.fromParts(Part.fromText("summary")))))
+            .summarizeEvents(CONFIRMED_CALL_EVENTS)
+            .blockingGet();
+    assertThat(compactionEvent).isNotNull();
+    assertThat(compactionEvent.author()).isEqualTo("user");
+    Session session =
+        Session.builder("session_id")
+            .events(
+                ImmutableList.<Event>builder()
+                    .addAll(CONFIRMED_CALL_EVENTS)
+                    .add(compactionEvent)
+                    .build())
+            .build();
+
+    assertThat(resumedEvents(agent, session)).isEmpty();
+  }
+
+  @Test
+  public void runAsync_stateDeltaOnlyEventAfterApproval_doesNotCallOriginalFunction() {
+    LlmAgent agent = createAgentWithEchoTool();
+    // A state-only user event, such as a resume without a message, ends the scan too.
+    Event stateDeltaEvent =
+        Event.builder()
+            .author("user")
+            .actions(EventActions.builder().stateDelta(ImmutableMap.of("resume_count", 1)).build())
+            .build();
+    Session session =
+        Session.builder("session_id")
+            .events(
+                ImmutableList.<Event>builder()
+                    .addAll(CONFIRMED_CALL_EVENTS)
+                    .add(stateDeltaEvent)
+                    .build())
+            .build();
+
+    assertThat(resumedEvents(agent, session)).isEmpty();
+  }
+
+  @Test
+  public void runAsync_userTextTurnAfterApproval_doesNotCallOriginalFunction() {
+    LlmAgent agent = createAgentWithEchoTool();
+    // The approved call never recorded a response; a later text turn must not re-run it.
+    Event laterUserTextEvent =
+        Event.builder()
+            .author("user")
+            .content(Content.fromParts(Part.fromText("unrelated follow-up question")))
+            .build();
+    Session session =
+        Session.builder("session_id")
+            .events(
+                ImmutableList.<Event>builder()
+                    .addAll(CONFIRMED_CALL_EVENTS)
+                    .add(laterUserTextEvent)
+                    .build())
+            .build();
+
+    assertThat(resumedEvents(agent, session)).isEmpty();
+  }
+
+  @Test
+  public void runAsync_laterUserTurnAnswersOtherFunctionCall_doesNotCallOriginalFunction() {
+    LlmAgent agent = createAgentWithEchoTool();
+    // The latest user event answers another function call, so the earlier approval stays unused.
+    Event otherFunctionResponseEvent =
+        Event.builder()
+            .author("user")
+            .content(
+                Content.fromParts(
+                    Part.builder()
+                        .functionResponse(
+                            FunctionResponse.builder()
+                                .id("other_fc_id")
+                                .name("other_tool")
+                                .response(ImmutableMap.of("result", "done"))
+                                .build())
+                        .build()))
+            .build();
+    Session session =
+        Session.builder("session_id")
+            .events(
+                ImmutableList.<Event>builder()
+                    .addAll(CONFIRMED_CALL_EVENTS)
+                    .add(otherFunctionResponseEvent)
+                    .build())
+            .build();
+
+    assertThat(resumedEvents(agent, session)).isEmpty();
+  }
+
   @Test
   public void runAsync_noUserConfirmationEvent_empty() {
     LlmAgent agent = createAgentWithEchoTool();