fix: Ensure function call ID is populated before building list of long running function calls

PiperOrigin-RevId: 784745132

Author: google-genai-bot

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

@@ -39,7 +39,6 @@
 import com.google.adk.tools.ToolContext;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-import com.google.genai.types.FunctionCall;
 import com.google.genai.types.FunctionResponse;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.StatusCode;
@@ -621,11 +620,10 @@ private Event buildModelResponseEvent(
 
     Event event = eventBuilder.build();
 
-    ImmutableList<FunctionCall> functionCalls = event.functionCalls();
-    if (!functionCalls.isEmpty()) {
+    if (!event.functionCalls().isEmpty()) {
       Functions.populateClientFunctionCallId(event);
       Set<String> longRunningToolIds =
-          Functions.getLongRunningFunctionCalls(functionCalls, llmRequest.tools());
+          Functions.getLongRunningFunctionCalls(event.functionCalls(), llmRequest.tools());
       if (!longRunningToolIds.isEmpty()) {
         event.setLongRunningToolIds(Optional.of(longRunningToolIds));
       }

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

@@ -135,6 +135,39 @@ public void run_withFunctionCallsAndMaxSteps_stopsAfterMaxSteps() {
         Content.fromParts(Part.fromFunctionResponse("my_function", testResponse)));
   }
 
+  @Test
+  public void run_withLongRunningFunctionCall_returnsCorrectEventsWithLongRunningToolIds() {
+    Content firstContent =
+        Content.fromParts(
+            Part.fromText("LLM response with function call"),
+            Part.fromFunctionCall("my_function", ImmutableMap.of("arg1", "value1")));
+    Content secondContent =
+        Content.fromParts(Part.fromText("LLM response after function response"));
+    TestLlm testLlm =
+        createTestLlm(
+            Flowable.just(createLlmResponse(firstContent)),
+            Flowable.just(createLlmResponse(secondContent)));
+    ImmutableMap<String, Object> testResponse =
+        ImmutableMap.<String, Object>of("response", "response for my_function");
+    InvocationContext invocationContext =
+        createInvocationContext(
+            createTestAgentBuilder(testLlm)
+                .tools(ImmutableList.of(new TestLongRunningTool("my_function", testResponse)))
+                .build());
+    BaseLlmFlow baseLlmFlow = createBaseLlmFlowWithoutProcessors();
+
+    List<Event> events = baseLlmFlow.run(invocationContext).toList().blockingGet();
+
+    assertThat(events).hasSize(3);
+    assertEqualIgnoringFunctionIds(events.get(0).content().get(), firstContent);
+    assertThat(events.get(0).longRunningToolIds().get())
+        .contains(events.get(0).functionCalls().get(0).id().get());
+    assertEqualIgnoringFunctionIds(
+        events.get(1).content().get(),
+        Content.fromParts(Part.fromFunctionResponse("my_function", testResponse)));
+    assertThat(events.get(2).content()).hasValue(secondContent);
+  }
+
   @Test
   public void run_withRequestProcessor_doesNotModifyRequest() {
     Content content = Content.fromParts(Part.fromText("LLM response"));
@@ -293,4 +326,23 @@ public Single<Map<String, Object>> runAsync(Map<String, Object> args, ToolContex
       return Single.just(response);
     }
   }
+
+  private static class TestLongRunningTool extends BaseTool {
+    private final Map<String, Object> response;
+
+    TestLongRunningTool(String name, Map<String, Object> response) {
+      super(name, "tool description for " + name, /* isLongRunning= */ true);
+      this.response = response;
+    }
+
+    @Override
+    public Optional<FunctionDeclaration> declaration() {
+      return Optional.of(FunctionDeclaration.builder().name(name()).build());
+    }
+
+    @Override
+    public Single<Map<String, Object>> runAsync(Map<String, Object> args, ToolContext toolContext) {
+      return Single.just(response);
+    }
+  }
 }