refactor: Extracting GeminiUtils from Gemini and adding tests

The tests found a bug in sanitizeRequest calling config.labels(null), which throws an NPE.  Other than that fix and a tweak on the name of sanitizeRequest, the code is a copy of Gemini.java

PiperOrigin-RevId: 803476406

Author: google-genai-bot

core/src/main/java/com/google/adk/models/Gemini.java

@@ -20,16 +20,13 @@
 import static com.google.common.collect.ImmutableList.toImmutableList;
 
 import com.google.adk.Version;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.genai.Client;
 import com.google.genai.ResponseStream;
-import com.google.genai.types.Blob;
 import com.google.genai.types.Candidate;
 import com.google.genai.types.Content;
-import com.google.genai.types.FileData;
 import com.google.genai.types.FinishReason;
 import com.google.genai.types.GenerateContentConfig;
 import com.google.genai.types.GenerateContentResponse;
@@ -226,60 +223,10 @@ public Gemini build() {
   private LlmRequest sanitizeRequest(LlmRequest llmRequest) {
     if (apiClient.vertexAI()) {
       return llmRequest;
+    } else {
+      // Using API key from Google AI Studio to call model doesn't support labels.
+      return GeminiUtil.sanitizeRequestForGeminiApi(llmRequest);
     }
-    LlmRequest.Builder requestBuilder = llmRequest.toBuilder();
-
-    // Using API key from Google AI Studio to call model doesn't support labels.
-    llmRequest
-        .config()
-        .ifPresent(
-            config -> {
-              if (config.labels().isPresent()) {
-                requestBuilder.config(config.toBuilder().labels(null).build());
-              }
-            });
-
-    if (llmRequest.contents().isEmpty()) {
-      return requestBuilder.build();
-    }
-
-    // This backend does not support the display_name parameter for file uploads,
-    // so it must be removed to prevent request failures.
-    ImmutableList<Content> updatedContents =
-        llmRequest.contents().stream()
-            .map(
-                content -> {
-                  if (content.parts().isEmpty() || content.parts().get().isEmpty()) {
-                    return content;
-                  }
-
-                  ImmutableList<Part> updatedParts =
-                      content.parts().get().stream()
-                          .map(
-                              part -> {
-                                Part.Builder partBuilder = part.toBuilder();
-                                if (part.inlineData().flatMap(Blob::displayName).isPresent()) {
-                                  Blob blob = part.inlineData().get();
-                                  Blob.Builder newBlobBuilder = Blob.builder();
-                                  blob.data().ifPresent(newBlobBuilder::data);
-                                  blob.mimeType().ifPresent(newBlobBuilder::mimeType);
-                                  partBuilder.inlineData(newBlobBuilder.build());
-                                }
-                                if (part.fileData().flatMap(FileData::displayName).isPresent()) {
-                                  FileData fileData = part.fileData().get();
-                                  FileData.Builder newFileDataBuilder = FileData.builder();
-                                  fileData.fileUri().ifPresent(newFileDataBuilder::fileUri);
-                                  fileData.mimeType().ifPresent(newFileDataBuilder::mimeType);
-                                  partBuilder.fileData(newFileDataBuilder.build());
-                                }
-                                return partBuilder.build();
-                              })
-                          .collect(toImmutableList());
-
-                  return content.toBuilder().parts(updatedParts).build();
-                })
-            .collect(toImmutableList());
-    return requestBuilder.contents(updatedContents).build();
   }
 
   @Override
@@ -293,7 +240,7 @@ public Flowable<LlmResponse> generateContent(LlmRequest llmRequest, boolean stre
           Stream.concat(contents.stream(), Stream.of(userContent)).collect(toImmutableList());
     }
 
-    List<Content> finalContents = stripThoughts(contents);
+    List<Content> finalContents = GeminiUtil.stripThoughts(contents);
     GenerateContentConfig config = llmRequest.config().orElse(null);
     String effectiveModelName = llmRequest.model().orElse(model());
 
@@ -320,7 +267,8 @@ public Flowable<LlmResponse> generateContent(LlmRequest llmRequest, boolean stre
 
                       List<LlmResponse> responsesToEmit = new ArrayList<>();
                       LlmResponse currentProcessedLlmResponse = LlmResponse.create(rawResponse);
-                      String currentTextChunk = getTextFromLlmResponse(currentProcessedLlmResponse);
+                      String currentTextChunk =
+                          GeminiUtil.getTextFromLlmResponse(currentProcessedLlmResponse);
 
                       if (!currentTextChunk.isEmpty()) {
                         accumulatedText.append(currentTextChunk);
@@ -329,17 +277,13 @@ public Flowable<LlmResponse> generateContent(LlmRequest llmRequest, boolean stre
                         responsesToEmit.add(partialResponse);
                       } else {
                         if (accumulatedText.length() > 0
-                            && shouldEmitAccumulatedText(currentProcessedLlmResponse)) {
+                            && GeminiUtil.shouldEmitAccumulatedText(currentProcessedLlmResponse)) {
                           LlmResponse aggregatedTextResponse =
                               LlmResponse.builder()
                                   .content(
                                       Content.builder()
                                           .role("model")
-                                          .parts(
-                                              ImmutableList.of(
-                                                  Part.builder()
-                                                      .text(accumulatedText.toString())
-                                                      .build()))
+                                          .parts(Part.fromText(accumulatedText.toString()))
                                           .build())
                                   .build();
                           responsesToEmit.add(aggregatedTextResponse);
@@ -376,11 +320,7 @@ && shouldEmitAccumulatedText(currentProcessedLlmResponse)) {
                                       .content(
                                           Content.builder()
                                               .role("model")
-                                              .parts(
-                                                  ImmutableList.of(
-                                                      Part.builder()
-                                                          .text(accumulatedText.toString())
-                                                          .build()))
+                                              .parts(Part.fromText(accumulatedText.toString()))
                                               .build())
                                       .build();
                               return Flowable.just(finalAggregatedTextResponse);
@@ -400,52 +340,6 @@ && shouldEmitAccumulatedText(currentProcessedLlmResponse)) {
     }
   }
 
-  /**
-   * Extracts text content from the first part of an LlmResponse, if available.
-   *
-   * @param llmResponse The LlmResponse to extract text from.
-   * @return The text content, or an empty string if not found.
-   */
-  private String getTextFromLlmResponse(LlmResponse llmResponse) {
-    return llmResponse
-        .content()
-        .flatMap(Content::parts)
-        .filter(parts -> !parts.isEmpty())
-        .map(parts -> parts.get(0))
-        .flatMap(Part::text)
-        .orElse("");
-  }
-
-  /**
-   * Determines if accumulated text should be emitted based on the current LlmResponse. We flush if
-   * current response is not a text continuation (e.g., no content, no parts, or the first part is
-   * not inline_data, meaning it's something else or just empty, thereby warranting a flush of
-   * preceding text).
-   *
-   * @param currentLlmResponse The current LlmResponse being processed.
-   * @return True if accumulated text should be emitted, false otherwise.
-   */
-  private boolean shouldEmitAccumulatedText(LlmResponse currentLlmResponse) {
-    Optional<Content> contentOpt = currentLlmResponse.content();
-    if (contentOpt.isEmpty()) {
-      return true;
-    }
-
-    Optional<List<Part>> partsOpt = contentOpt.get().parts();
-    if (partsOpt.isEmpty() || partsOpt.get().isEmpty()) {
-      return true;
-    }
-
-    // If content and parts are present, and parts list is not empty, we want to yield accumulated
-    // text only if `text` is present AND (`not llm_response.content` OR `not
-    // llm_response.content.parts` OR `not llm_response.content.parts[0].inline_data`)
-    // This means we flush if the first part does NOT have inline_data.
-    // If it *has* inline_data, the condition below is false,
-    // and we would not flush based on this specific sub-condition.
-    Part firstPart = partsOpt.get().get(0);
-    return firstPart.inlineData().isEmpty();
-  }
-
   @Override
   public BaseLlmConnection connect(LlmRequest llmRequest) {
     llmRequest = sanitizeRequest(llmRequest);
@@ -458,18 +352,4 @@ public BaseLlmConnection connect(LlmRequest llmRequest) {
 
     return new GeminiLlmConnection(apiClient, effectiveModelName, liveConnectConfig);
   }
-
-  /** Removes any `Part` that contains only a `thought` from the content list. */
-  private List<Content> stripThoughts(List<Content> originalContents) {
-    List<Content> updatedContents = new ArrayList<>();
-    for (Content content : originalContents) {
-      ImmutableList<Part> nonThoughtParts =
-          content.parts().orElse(ImmutableList.of()).stream()
-              // Keep if thought is not present OR if thought is present but false
-              .filter(part -> part.thought().map(isThought -> !isThought).orElse(true))
-              .collect(toImmutableList());
-      updatedContents.add(content.toBuilder().parts(nonThoughtParts).build());
-    }
-    return updatedContents;
-  }
 }

core/src/main/java/com/google/adk/models/GeminiUtil.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.adk.models;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.genai.types.Blob;
+import com.google.genai.types.Content;
+import com.google.genai.types.FileData;
+import com.google.genai.types.Part;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/** Request / Response utilities for {@link Gemini}. */
+public final class GeminiUtil {
+
+  private GeminiUtil() {}
+
+  /**
+   * Sanitizes the request to ensure it is compatible with the Gemini API backend. Required as there
+   * are some parameters that if included in the request will raise a runtime error if sent to the
+   * wrong backend (e.g. image names only work on Vertex AI).
+   *
+   * @param llmRequest The request to sanitize.
+   * @return The sanitized request.
+   */
+  public static LlmRequest sanitizeRequestForGeminiApi(LlmRequest llmRequest) {
+    LlmRequest.Builder requestBuilder = llmRequest.toBuilder();
+    llmRequest
+        .config()
+        .ifPresent(
+            config -> {
+              if (config.labels().isPresent()) {
+                requestBuilder.config(config.toBuilder().labels(ImmutableMap.of()).build());
+              }
+            });
+
+    if (llmRequest.contents().isEmpty()) {
+      return requestBuilder.build();
+    }
+
+    // This backend does not support the display_name parameter for file uploads,
+    // so it must be removed to prevent request failures.
+    ImmutableList<Content> updatedContents =
+        llmRequest.contents().stream()
+            .map(
+                content -> {
+                  if (content.parts().isEmpty() || content.parts().get().isEmpty()) {
+                    return content;
+                  }
+
+                  ImmutableList<Part> updatedParts =
+                      content.parts().get().stream()
+                          .map(
+                              part -> {
+                                Part.Builder partBuilder = part.toBuilder();
+                                if (part.inlineData().flatMap(Blob::displayName).isPresent()) {
+                                  Blob blob = part.inlineData().get();
+                                  Blob.Builder newBlobBuilder = Blob.builder();
+                                  blob.data().ifPresent(newBlobBuilder::data);
+                                  blob.mimeType().ifPresent(newBlobBuilder::mimeType);
+                                  partBuilder.inlineData(newBlobBuilder.build());
+                                }
+                                if (part.fileData().flatMap(FileData::displayName).isPresent()) {
+                                  FileData fileData = part.fileData().get();
+                                  FileData.Builder newFileDataBuilder = FileData.builder();
+                                  fileData.fileUri().ifPresent(newFileDataBuilder::fileUri);
+                                  fileData.mimeType().ifPresent(newFileDataBuilder::mimeType);
+                                  partBuilder.fileData(newFileDataBuilder.build());
+                                }
+                                return partBuilder.build();
+                              })
+                          .collect(toImmutableList());
+
+                  return content.toBuilder().parts(updatedParts).build();
+                })
+            .collect(toImmutableList());
+    return requestBuilder.contents(updatedContents).build();
+  }
+
+  /**
+   * Extracts text content from the first part of an LlmResponse, if available.
+   *
+   * @param llmResponse The LlmResponse to extract text from.
+   * @return The text content, or an empty string if not found.
+   */
+  public static String getTextFromLlmResponse(LlmResponse llmResponse) {
+    return llmResponse
+        .content()
+        .flatMap(Content::parts)
+        .filter(parts -> !parts.isEmpty())
+        .map(parts -> parts.get(0))
+        .flatMap(Part::text)
+        .orElse("");
+  }
+
+  /**
+   * Determines if accumulated text should be emitted based on the current LlmResponse. We flush if
+   * current response is not a text continuation (e.g., no content, no parts, or the first part is
+   * not inline_data, meaning it's something else or just empty, thereby warranting a flush of
+   * preceding text).
+   *
+   * @param currentLlmResponse The current LlmResponse being processed.
+   * @return True if accumulated text should be emitted, false otherwise.
+   */
+  public static boolean shouldEmitAccumulatedText(LlmResponse currentLlmResponse) {
+    Optional<Content> contentOpt = currentLlmResponse.content();
+    if (contentOpt.isEmpty()) {
+      return true;
+    }
+
+    Optional<List<Part>> partsOpt = contentOpt.get().parts();
+    if (partsOpt.isEmpty() || partsOpt.get().isEmpty()) {
+      return true;
+    }
+
+    // If content and parts are present, and parts list is not empty, we want to yield accumulated
+    // text only if `text` is present AND (`not llm_response.content` OR `not
+    // llm_response.content.parts` OR `not llm_response.content.parts[0].inline_data`)
+    // This means we flush if the first part does NOT have inline_data.
+    // If it *has* inline_data, the condition below is false,
+    // and we would not flush based on this specific sub-condition.
+    Part firstPart = partsOpt.get().get(0);
+    return firstPart.inlineData().isEmpty();
+  }
+
+  /** Removes any `Part` that contains only a `thought` from the content list. */
+  public static List<Content> stripThoughts(List<Content> originalContents) {
+    List<Content> updatedContents = new ArrayList<>();
+    for (Content content : originalContents) {
+      ImmutableList<Part> nonThoughtParts =
+          content.parts().orElse(ImmutableList.of()).stream()
+              // Keep if thought is not present OR if thought is present but false
+              .filter(part -> part.thought().map(isThought -> !isThought).orElse(true))
+              .collect(toImmutableList());
+      updatedContents.add(content.toBuilder().parts(nonThoughtParts).build());
+    }
+    return updatedContents;
+  }
+}