fix(core): stop re-applying a tool confirmation after a later user turn

RequestConfirmationLlmRequestProcessor scanned past user events that carried
no function responses, so an approval answered several turns earlier was
matched again on every later LLM call. When the approved call had not left a
function response (for example because its execution was aborted), the tool
was silently re-executed with its original arguments on the next, unrelated
user message.

Stop the scan at the most recent user event, as the ADK Python processor
does: a user turn without request-confirmation responses means there is
nothing left to resume.

Author: innoprej

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

@@ -85,9 +85,9 @@ public Single<RequestProcessor.RequestProcessingResult> processRequest(
     // 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.
+    // findMostRecentConfirmations re-matches the same user event on every later LLM call of the
+    // invocation that answered it, so a settled confirmation would otherwise be re-examined - and
+    // re-logged - until the next user turn.
     //
     // 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,13 +167,19 @@ 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.
+    // Only the most recent user event can answer a pending confirmation. A later user turn that
+    // carries no confirmation responses (a plain text message, or responses to other function
+    // calls) means the approval was already consumed or abandoned; scanning past it would re-apply
+    // the stale approval on every later LLM call. This mirrors ADK Python's processor, which
+    // returns as soon as the latest user event has no function responses.
     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;
       }
+      if (event.functionResponses().isEmpty()) {
+        return Optional.empty();
+      }
 
       ImmutableMap<String, ToolConfirmation> confirmationsInEvent =
           event.functionResponses().stream()
@@ -186,9 +192,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

@@ -208,6 +208,61 @@ public void runAsync_noEvents_empty() {
         .isEmpty();
   }
 
+  @Test
+  public void runAsync_userTextTurnAfterApproval_doesNotCallOriginalFunction() {
+    LlmAgent agent = createAgentWithEchoTool();
+    // The approved call never produced a function response (its execution was aborted) and the
+    // user has since sent a plain text turn. ADK Python stops the scan at that turn, so the stale
+    // approval must not be applied again on this later LLM call.
+    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 most recent user event answers some other function call, not a confirmation request.
+    // Only that latest user turn is consulted, as in ADK Python, so the earlier approval is not
+    // re-applied either.
+    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();