Merge branch 'main' into fix/persist-barrier-stackoverflow

Author: zhangxiangnan

contrib/spring-ai/src/main/java/com/google/adk/models/springai/MessageConverter.java

@@ -83,6 +83,26 @@ public MessageConverter(ObjectMapper objectMapper) {
    * @return A Spring AI Prompt
    */
   public Prompt toLlmPrompt(LlmRequest llmRequest) {
+    return toLlmPrompt(llmRequest, null);
+  }
+
+  /**
+   * Converts an ADK LlmRequest to a Spring AI Prompt, using the target model's own default options
+   * as the base for the prompt options.
+   *
+   * <p>Provider-specific chat models (for example Spring AI OpenAI {@code 2.0.0}) cast {@code
+   * Prompt.getOptions()} directly to their own options type (e.g. {@code OpenAiChatOptions}) in
+   * {@code createRequest(...)}. Passing provider-neutral options such as {@code
+   * DefaultToolCallingChatOptions} therefore triggers a {@link ClassCastException}. To stay
+   * compatible with any provider, the prompt options are built on top of the model's own default
+   * options (obtained via {@code ChatModel.getOptions()}) so the resulting options keep the
+   * concrete type the provider expects, while overlaying the ADK tools and generation config.
+   *
+   * @param llmRequest The ADK request to convert
+   * @param modelDefaultOptions The target model's default options, or {@code null} if unavailable
+   * @return A Spring AI Prompt
+   */
+  public Prompt toLlmPrompt(LlmRequest llmRequest, ChatOptions modelDefaultOptions) {
     List<Message> messages = new ArrayList<>();
     List<String> allSystemMessages = new ArrayList<>();
 
@@ -119,56 +139,90 @@ public Prompt toLlmPrompt(LlmRequest llmRequest) {
     // Add all non-system messages
     messages.addAll(nonSystemMessages);
 
-    // Convert config to ChatOptions
-    ChatOptions chatOptions = configMapper.toSpringAiChatOptions(llmRequest.config());
+    return new Prompt(messages, buildChatOptions(llmRequest, modelDefaultOptions));
+  }
 
-    // Convert ADK tools to Spring AI ToolCallback and add to ChatOptions
+  /**
+   * Builds the Spring AI {@link ChatOptions} for a request by overlaying the ADK generation config
+   * and tools on top of the model's own default options.
+   *
+   * @param llmRequest The ADK request being converted
+   * @param modelDefaultOptions The target model's default options, or {@code null} if unavailable
+   * @return The chat options to attach to the prompt, or {@code null} when there is nothing
+   *     ADK-specific to configure (letting the model apply its own defaults)
+   */
+  private ChatOptions buildChatOptions(LlmRequest llmRequest, ChatOptions modelDefaultOptions) {
+    // ADK generation config (temperature, max tokens, ...) as provider-neutral options.
+    ChatOptions adkChatOptions = configMapper.toSpringAiChatOptions(llmRequest.config());
+
+    // ADK tools converted to Spring AI tool callbacks.
+    List<ToolCallback> toolCallbacks = List.of();
     if (llmRequest.tools() != null && !llmRequest.tools().isEmpty()) {
-      List<ToolCallback> toolCallbacks = toolConverter.convertToSpringAiTools(llmRequest.tools());
-      if (!toolCallbacks.isEmpty()) {
-        // Create new ChatOptions with tools included
-        ToolCallingChatOptions.Builder optionsBuilder = ToolCallingChatOptions.builder();
+      toolCallbacks = toolConverter.convertToSpringAiTools(llmRequest.tools());
+    }
 
-        // Always set tool callbacks
-        optionsBuilder.toolCallbacks(toolCallbacks);
+    boolean hasTools = !toolCallbacks.isEmpty();
+    boolean hasAdkConfig = adkChatOptions != null;
 
-        // Copy existing chat options properties if present
-        if (chatOptions != null) {
-          // Copy all relevant properties from existing ChatOptions
-          if (chatOptions.getTemperature() != null) {
-            optionsBuilder.temperature(chatOptions.getTemperature());
-          }
-          if (chatOptions.getMaxTokens() != null) {
-            optionsBuilder.maxTokens(chatOptions.getMaxTokens());
-          }
-          if (chatOptions.getTopP() != null) {
-            optionsBuilder.topP(chatOptions.getTopP());
-          }
-          if (chatOptions.getTopK() != null) {
-            optionsBuilder.topK(chatOptions.getTopK());
-          }
-          if (chatOptions.getStopSequences() != null) {
-            optionsBuilder.stopSequences(chatOptions.getStopSequences());
-          }
-          // Copy model name if present
-          if (chatOptions.getModel() != null) {
-            optionsBuilder.model(chatOptions.getModel());
-          }
-          // Copy frequency penalty if present
-          if (chatOptions.getFrequencyPenalty() != null) {
-            optionsBuilder.frequencyPenalty(chatOptions.getFrequencyPenalty());
-          }
-          // Copy presence penalty if present
-          if (chatOptions.getPresencePenalty() != null) {
-            optionsBuilder.presencePenalty(chatOptions.getPresencePenalty());
-          }
-        }
+    // Nothing ADK-specific to add: let the provider fall back to its own default options.
+    if (!hasTools && !hasAdkConfig) {
+      return null;
+    }
 
-        chatOptions = optionsBuilder.build();
+    // Preferred path: start from the model's own options so the resulting options keep the concrete
+    // provider type (e.g. OpenAiChatOptions) and preserve provider-specific settings such as the
+    // API key, base URL and model name. This avoids the ClassCastException thrown by providers
+    // (like Spring AI OpenAI 2.0.0) that cast Prompt.getOptions() to their own options type.
+    if (modelDefaultOptions instanceof ToolCallingChatOptions) {
+      ToolCallingChatOptions.Builder<?> optionsBuilder =
+          ((ToolCallingChatOptions) modelDefaultOptions).mutate();
+      if (hasTools) {
+        optionsBuilder.toolCallbacks(toolCallbacks);
       }
+      applyGenerationConfig(optionsBuilder, adkChatOptions);
+      return optionsBuilder.build();
     }
 
-    return new Prompt(messages, chatOptions);
+    // Fallback: the model's default options are unavailable or not tool-calling capable. Preserve
+    // the provider-neutral behavior, which works for providers that normalize generic options.
+    if (hasTools) {
+      ToolCallingChatOptions.Builder<?> optionsBuilder = ToolCallingChatOptions.builder();
+      optionsBuilder.toolCallbacks(toolCallbacks);
+      applyGenerationConfig(optionsBuilder, adkChatOptions);
+      return optionsBuilder.build();
+    }
+    return adkChatOptions;
+  }
+
+  /** Copies the non-null generation parameters from {@code source} onto {@code builder}. */
+  private void applyGenerationConfig(ChatOptions.Builder<?> builder, ChatOptions source) {
+    if (source == null) {
+      return;
+    }
+    if (source.getTemperature() != null) {
+      builder.temperature(source.getTemperature());
+    }
+    if (source.getMaxTokens() != null) {
+      builder.maxTokens(source.getMaxTokens());
+    }
+    if (source.getTopP() != null) {
+      builder.topP(source.getTopP());
+    }
+    if (source.getTopK() != null) {
+      builder.topK(source.getTopK());
+    }
+    if (source.getStopSequences() != null) {
+      builder.stopSequences(source.getStopSequences());
+    }
+    if (source.getModel() != null) {
+      builder.model(source.getModel());
+    }
+    if (source.getFrequencyPenalty() != null) {
+      builder.frequencyPenalty(source.getFrequencyPenalty());
+    }
+    if (source.getPresencePenalty() != null) {
+      builder.presencePenalty(source.getPresencePenalty());
+    }
   }
 
   /**

contrib/spring-ai/src/main/java/com/google/adk/models/springai/SpringAI.java

@@ -29,6 +29,7 @@
 import org.springframework.ai.chat.model.ChatModel;
 import org.springframework.ai.chat.model.ChatResponse;
 import org.springframework.ai.chat.model.StreamingChatModel;
+import org.springframework.ai.chat.prompt.ChatOptions;
 import org.springframework.ai.chat.prompt.Prompt;
 import reactor.core.publisher.Flux;
 
@@ -170,7 +171,7 @@ private Flowable<LlmResponse> generateContent(LlmRequest llmRequest) {
         observabilityHandler.startRequest(model(), "chat");
 
     try {
-      Prompt prompt = messageConverter.toLlmPrompt(llmRequest);
+      Prompt prompt = messageConverter.toLlmPrompt(llmRequest, resolveDefaultOptions());
       observabilityHandler.logRequest(prompt.toString(), model());
 
       ChatResponse chatResponse = chatModel.call(prompt);
@@ -200,7 +201,7 @@ private Flowable<LlmResponse> generateStreamingContent(LlmRequest llmRequest) {
     return Flowable.create(
         emitter -> {
           try {
-            Prompt prompt = messageConverter.toLlmPrompt(llmRequest);
+            Prompt prompt = messageConverter.toLlmPrompt(llmRequest, resolveDefaultOptions());
             observabilityHandler.logRequest(prompt.toString(), model());
 
             Flux<ChatResponse> responseFlux = streamingChatModel.stream(prompt);
@@ -256,6 +257,25 @@ public BaseLlmConnection connect(LlmRequest llmRequest) {
         "Live connection is not supported for Spring AI models.");
   }
 
+  /**
+   * Returns the underlying model's own default {@link ChatOptions}, or {@code null} if they cannot
+   * be determined.
+   *
+   * <p>These are used as the base for the prompt options so provider-specific models (e.g. Spring
+   * AI OpenAI) receive options of the concrete type they expect, avoiding a {@link
+   * ClassCastException} when they cast {@code Prompt.getOptions()} to their provider-specific
+   * options type.
+   */
+  private ChatOptions resolveDefaultOptions() {
+    if (chatModel != null) {
+      return chatModel.getOptions();
+    }
+    if (streamingChatModel instanceof ChatModel) {
+      return ((ChatModel) streamingChatModel).getOptions();
+    }
+    return null;
+  }
+
   private static String extractModelName(Object model) {
     // Spring AI models may not always have a straightforward way to get model name
     // This is a fallback that can be overridden by providing explicit model name

contrib/spring-ai/src/test/java/com/google/adk/models/springai/MessageConverterTest.java

@@ -21,12 +21,17 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.adk.models.LlmRequest;
 import com.google.adk.models.LlmResponse;
+import com.google.adk.tools.BaseTool;
 import com.google.genai.types.Content;
 import com.google.genai.types.FunctionCall;
+import com.google.genai.types.FunctionDeclaration;
 import com.google.genai.types.FunctionResponse;
+import com.google.genai.types.GenerateContentConfig;
 import com.google.genai.types.Part;
+import com.google.genai.types.Schema;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.ai.chat.messages.AssistantMessage;
@@ -37,7 +42,10 @@
 import org.springframework.ai.chat.metadata.DefaultUsage;
 import org.springframework.ai.chat.model.ChatResponse;
 import org.springframework.ai.chat.model.Generation;
+import org.springframework.ai.chat.prompt.ChatOptions;
 import org.springframework.ai.chat.prompt.Prompt;
+import org.springframework.ai.model.tool.ToolCallingChatOptions;
+import org.springframework.ai.openai.OpenAiChatOptions;
 
 class MessageConverterTest {
 
@@ -667,6 +675,104 @@ void testUserMessageWithInvalidMimeTypeGracefullySkipsMediaPart() {
     assertThat(userMessage.getMedia()).isEmpty();
   }
 
+  private static BaseTool testTool() {
+    FunctionDeclaration function =
+        FunctionDeclaration.builder()
+            .name("get_weather")
+            .description("Get the current weather for a location")
+            .parameters(
+                Schema.builder()
+                    .type("OBJECT")
+                    .properties(Map.of("location", Schema.builder().type("STRING").build()))
+                    .required(List.of("location"))
+                    .build())
+            .build();
+    return new BaseTool("get_weather", "Get the current weather for a location") {
+      @Override
+      public Optional<FunctionDeclaration> declaration() {
+        return Optional.of(function);
+      }
+    };
+  }
+
+  @Test
+  void testToolOptionsPreserveProviderSpecificTypeToAvoidClassCastException() {
+    // Regression test for b/527041291 (GitHub adk-java #1295): Spring AI OpenAI 2.0.0 casts
+    // Prompt.getOptions() directly to OpenAiChatOptions in createRequest(). When ADK passed a
+    // provider-neutral DefaultToolCallingChatOptions, that cast threw a ClassCastException. Basing
+    // the prompt options on the model's own options must keep the concrete provider type.
+    OpenAiChatOptions modelDefaultOptions =
+        OpenAiChatOptions.builder().model("gpt-4o").apiKey("dummy-key").build();
+
+    LlmRequest request =
+        LlmRequest.builder()
+            .contents(
+                List.of(
+                    Content.builder()
+                        .role("user")
+                        .parts(List.of(Part.fromText("What's the weather in Paris?")))
+                        .build()))
+            .tools(Map.of("get_weather", testTool()))
+            .build();
+
+    Prompt prompt = messageConverter.toLlmPrompt(request, modelDefaultOptions);
+
+    ChatOptions options = prompt.getOptions();
+    // The exact cast performed by OpenAiChatModel.createRequest(...); must not throw.
+    assertThat(options).isInstanceOf(OpenAiChatOptions.class);
+    OpenAiChatOptions openAiOptions = (OpenAiChatOptions) options;
+
+    // Tools are attached and provider-specific settings are preserved from the model defaults.
+    assertThat(openAiOptions.getToolCallbacks()).hasSize(1);
+    assertThat(openAiOptions.getModel()).isEqualTo("gpt-4o");
+    assertThat(openAiOptions.getApiKey()).isEqualTo("dummy-key");
+  }
+
+  @Test
+  void testProviderOptionsPreservedWithConfigOnlyAndNoTools() {
+    // Even without tools, provider-neutral options previously reached the provider cast. Ensure the
+    // provider-specific type is preserved and the ADK generation config is overlaid.
+    OpenAiChatOptions modelDefaultOptions =
+        OpenAiChatOptions.builder().model("gpt-4o").apiKey("dummy-key").build();
+
+    LlmRequest request =
+        LlmRequest.builder()
+            .contents(
+                List.of(
+                    Content.builder().role("user").parts(List.of(Part.fromText("Hello"))).build()))
+            .config(GenerateContentConfig.builder().temperature(0.25f).build())
+            .build();
+
+    Prompt prompt = messageConverter.toLlmPrompt(request, modelDefaultOptions);
+
+    ChatOptions options = prompt.getOptions();
+    assertThat(options).isInstanceOf(OpenAiChatOptions.class);
+    assertThat(options.getModel()).isEqualTo("gpt-4o");
+    assertThat(options.getTemperature()).isEqualTo(0.25);
+  }
+
+  @Test
+  void testToolOptionsFallBackToGenericWhenNoProviderDefaults() {
+    // When the model's default options are unavailable, keep the provider-neutral behavior so
+    // providers that normalize generic options continue to work.
+    LlmRequest request =
+        LlmRequest.builder()
+            .contents(
+                List.of(
+                    Content.builder()
+                        .role("user")
+                        .parts(List.of(Part.fromText("What's the weather in Paris?")))
+                        .build()))
+            .tools(Map.of("get_weather", testTool()))
+            .build();
+
+    Prompt prompt = messageConverter.toLlmPrompt(request);
+
+    ChatOptions options = prompt.getOptions();
+    assertThat(options).isInstanceOf(ToolCallingChatOptions.class);
+    assertThat(((ToolCallingChatOptions) options).getToolCallbacks()).hasSize(1);
+  }
+
   @Test
   void testUserMessageWithMediaOnly() {
     // Test conversion with media but no text

core/src/main/java/com/google/adk/agents/RunConfig.java

@@ -18,11 +18,13 @@
 
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.genai.types.AudioTranscriptionConfig;
 import com.google.genai.types.AvatarConfig;
 import com.google.genai.types.Modality;
 import com.google.genai.types.SpeechConfig;
+import java.util.Map;
 import org.jspecify.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -94,6 +96,8 @@ public enum ToolExecutionMode {
   @Deprecated
   public abstract boolean groupFunctionResponsesInHistory();
 
+  public abstract ImmutableMap<String, Object> customMetadata();
+
   public abstract Builder toBuilder();
 
   @SuppressWarnings("deprecation") // Sets the workaround flag's default.
@@ -105,7 +109,8 @@ public static Builder builder() {
         .toolExecutionMode(ToolExecutionMode.NONE)
         .maxLlmCalls(500)
         .autoCreateSession(false)
-        .groupFunctionResponsesInHistory(false);
+        .groupFunctionResponsesInHistory(false)
+        .customMetadata(ImmutableMap.of());
   }
 
   @SuppressWarnings("deprecation") // Propagates the workaround flag.
@@ -121,7 +126,8 @@ public static Builder builder(RunConfig runConfig) {
         .outputAudioTranscription(runConfig.outputAudioTranscription())
         .inputAudioTranscription(runConfig.inputAudioTranscription())
         .autoCreateSession(runConfig.autoCreateSession())
-        .groupFunctionResponsesInHistory(runConfig.groupFunctionResponsesInHistory());
+        .groupFunctionResponsesInHistory(runConfig.groupFunctionResponsesInHistory())
+        .customMetadata(runConfig.customMetadata());
   }
 
   /** Builder for {@link RunConfig}. */
@@ -216,6 +222,9 @@ public final Builder setAutoCreateSession(boolean autoCreateSession) {
     @CanIgnoreReturnValue
     public abstract Builder autoCreateSession(boolean autoCreateSession);
 
+    @CanIgnoreReturnValue
+    public abstract Builder customMetadata(Map<String, Object> customMetadata);
+
     /**
      * @deprecated Expected only for specific model endpoints.
      */