refactor: replace genAI model sdk by okHttp

agentscope-core/pom.xml

@@ -97,11 +97,6 @@
             </exclusions>
         </dependency>
 
-        <!-- Google Gemini Java SDK -->
-        <dependency>
-            <groupId>com.google.genai</groupId>
-            <artifactId>google-genai</artifactId>
-        </dependency>
 
         <!-- Anthropic Java SDK -->
         <dependency>

agentscope-core/src/main/java/io/agentscope/core/formatter/gemini/GeminiChatFormatter.java

@@ -15,45 +15,43 @@
  */
 package io.agentscope.core.formatter.gemini;
 
-import com.google.genai.types.Content;
-import com.google.genai.types.GenerateContentConfig;
-import com.google.genai.types.GenerateContentResponse;
-import com.google.genai.types.ThinkingConfig;
-import com.google.genai.types.Tool;
-import com.google.genai.types.ToolConfig;
 import io.agentscope.core.formatter.AbstractBaseFormatter;
+import io.agentscope.core.formatter.gemini.dto.GeminiContent;
+import io.agentscope.core.formatter.gemini.dto.GeminiGenerationConfig;
+import io.agentscope.core.formatter.gemini.dto.GeminiGenerationConfig.GeminiThinkingConfig;
+import io.agentscope.core.formatter.gemini.dto.GeminiRequest;
+import io.agentscope.core.formatter.gemini.dto.GeminiResponse;
+import io.agentscope.core.formatter.gemini.dto.GeminiTool;
+import io.agentscope.core.formatter.gemini.dto.GeminiToolConfig;
 import io.agentscope.core.message.Msg;
 import io.agentscope.core.model.ChatResponse;
 import io.agentscope.core.model.GenerateOptions;
 import io.agentscope.core.model.ToolChoice;
 import io.agentscope.core.model.ToolSchema;
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
 
 /**
  * Formatter for Gemini Content Generation API.
  *
- * <p>Converts between AgentScope Msg objects and Gemini SDK types:
+ * <p>
+ * Converts between AgentScope Msg objects and Gemini API DTOs:
  * <ul>
- *   <li>Msg → Content (request format)</li>
- *   <li>GenerateContentResponse → ChatResponse (response parsing)</li>
- *   <li>ToolSchema → Tool (tool definitions)</li>
- * </ul>
- *
- * <p><b>Important Gemini API Behaviors:</b>
- * <ul>
- *   <li>System messages are converted to "user" role (Gemini doesn't support system role in contents)</li>
- *   <li>Tool results are independent "user" role Content objects</li>
- *   <li>Thinking content uses the "thought" flag on Part objects</li>
+ * <li>Msg → GeminiContent (request format)</li>
+ * <li>GeminiResponse → ChatResponse (response parsing)</li>
+ * <li>ToolSchema → GeminiTool (tool definitions)</li>
  * </ul>
  */
 public class GeminiChatFormatter
-        extends AbstractBaseFormatter<
-                Content, GenerateContentResponse, GenerateContentConfig.Builder> {
+        extends AbstractBaseFormatter<GeminiContent, GeminiResponse, GeminiRequest> {
 
     private final GeminiMessageConverter messageConverter;
     private final GeminiResponseParser responseParser;
     private final GeminiToolsHelper toolsHelper;
+    private GeminiContent systemInstruction;
 
     /**
      * Creates a new GeminiChatFormatter with default converters and parsers.
@@ -65,142 +63,194 @@ public GeminiChatFormatter() {
     }
 
     @Override
-    protected List<Content> doFormat(List<Msg> msgs) {
-        return messageConverter.convertMessages(msgs);
+    protected List<GeminiContent> doFormat(List<Msg> msgs) {
+        // Extract and store SYSTEM message separately
+        systemInstruction = null;
+        int startIndex = 0;
+
+        if (!msgs.isEmpty() && msgs.get(0).getRole() == io.agentscope.core.message.MsgRole.SYSTEM) {
+            systemInstruction = messageConverter.convertMessages(List.of(msgs.get(0))).get(0);
+            startIndex = 1;
+        }
+
+        // Gemini API requires contents to start with "user" role
+        // If first remaining message is ASSISTANT (from another agent), convert it to USER
+        if (startIndex < msgs.size()
+                && msgs.get(startIndex).getRole() == io.agentscope.core.message.MsgRole.ASSISTANT) {
+            List<GeminiContent> result = new ArrayList<>();
+
+            // Convert first ASSISTANT message to USER role for multi-agent compatibility
+            GeminiContent userContent = new GeminiContent();
+            userContent.setRole("user");
+            userContent.setParts(
+                    messageConverter
+                            .convertMessages(List.of(msgs.get(startIndex)))
+                            .get(0)
+                            .getParts());
+            result.add(userContent);
+
+            // Add remaining messages
+            if (startIndex + 1 < msgs.size()) {
+                result.addAll(
+                        messageConverter.convertMessages(
+                                msgs.subList(startIndex + 1, msgs.size())));
+            }
+
+            return result;
+        }
+
+        // Return remaining messages (excluding SYSTEM)
+        if (startIndex > 0 && startIndex < msgs.size()) {
+            return messageConverter.convertMessages(msgs.subList(startIndex, msgs.size()));
+        } else if (startIndex == 0) {
+            return messageConverter.convertMessages(msgs);
+        }
+
+        return new ArrayList<>();
+    }
+
+    /**
+     * Apply system instruction to the request if present.
+     *
+     * @param request The Gemini request to configure
+     */
+    public void applySystemInstruction(GeminiRequest request) {
+        if (systemInstruction != null) {
+            request.setSystemInstruction(systemInstruction);
+        }
     }
 
     @Override
-    public ChatResponse parseResponse(GenerateContentResponse response, Instant startTime) {
+    public ChatResponse parseResponse(GeminiResponse response, Instant startTime) {
         return responseParser.parseResponse(response, startTime);
     }
 
     @Override
     public void applyOptions(
-            GenerateContentConfig.Builder configBuilder,
-            GenerateOptions options,
-            GenerateOptions defaultOptions) {
+            GeminiRequest request, GenerateOptions options, GenerateOptions defaultOptions) {
+
+        // Ensure generation config exists
+        if (request.getGenerationConfig() == null) {
+            request.setGenerationConfig(new GeminiGenerationConfig());
+        }
+        GeminiGenerationConfig config = request.getGenerationConfig();
 
         // Apply each option with fallback to defaultOptions
-        applyFloatOption(
-                GenerateOptions::getTemperature,
-                options,
-                defaultOptions,
-                configBuilder::temperature);
+        applyDoubleOption(
+                GenerateOptions::getTemperature, options, defaultOptions, config::setTemperature);
 
-        applyFloatOption(GenerateOptions::getTopP, options, defaultOptions, configBuilder::topP);
+        applyDoubleOption(GenerateOptions::getTopP, options, defaultOptions, config::setTopP);
 
-        // Apply topK (Gemini uses Float for topK)
-        applyIntegerAsFloatOption(
-                GenerateOptions::getTopK, options, defaultOptions, configBuilder::topK);
+        // topK: Integer in GenerateOptions -> Double in GeminiGenerationConfig
+        applyIntegerAsDoubleOption(
+                GenerateOptions::getTopK, options, defaultOptions, config::setTopK);
 
-        // Apply seed
-        applyLongAsIntOption(
-                GenerateOptions::getSeed, options, defaultOptions, configBuilder::seed);
+        // seed: Long in GenerateOptions -> Integer in GeminiGenerationConfig
+        applyLongAsIntegerOption(
+                GenerateOptions::getSeed, options, defaultOptions, config::setSeed);
 
         applyIntegerOption(
-                GenerateOptions::getMaxTokens,
-                options,
-                defaultOptions,
-                configBuilder::maxOutputTokens);
+                GenerateOptions::getMaxTokens, options, defaultOptions, config::setMaxOutputTokens);
 
-        applyFloatOption(
+        applyDoubleOption(
                 GenerateOptions::getFrequencyPenalty,
                 options,
                 defaultOptions,
-                configBuilder::frequencyPenalty);
+                config::setFrequencyPenalty);
 
-        applyFloatOption(
+        applyDoubleOption(
                 GenerateOptions::getPresencePenalty,
                 options,
                 defaultOptions,
-                configBuilder::presencePenalty);
+                config::setPresencePenalty);
 
         // Apply ThinkingConfig if either includeThoughts or thinkingBudget is set
         Integer thinkingBudget =
                 getOptionOrDefault(options, defaultOptions, GenerateOptions::getThinkingBudget);
 
         if (thinkingBudget != null) {
-            ThinkingConfig.Builder thinkingConfigBuilder = ThinkingConfig.builder();
-            thinkingConfigBuilder.includeThoughts(true);
-            thinkingConfigBuilder.thinkingBudget(thinkingBudget);
-            configBuilder.thinkingConfig(thinkingConfigBuilder.build());
+            GeminiThinkingConfig thinkingConfig = new GeminiThinkingConfig();
+            thinkingConfig.setIncludeThoughts(true);
+            thinkingConfig.setThinkingBudget(thinkingBudget);
+            config.setThinkingConfig(thinkingConfig);
         }
     }
 
     /**
-     * Apply Float option with fallback logic.
+     * Apply Double option with fallback logic.
      */
-    private void applyFloatOption(
-            java.util.function.Function<GenerateOptions, Double> accessor,
+    private void applyDoubleOption(
+            Function<GenerateOptions, Double> accessor,
             GenerateOptions options,
             GenerateOptions defaultOptions,
-            java.util.function.Consumer<Float> setter) {
+            Consumer<Double> setter) {
 
         Double value = getOptionOrDefault(options, defaultOptions, accessor);
         if (value != null) {
-            setter.accept(value.floatValue());
+            setter.accept(value);
         }
     }
 
     /**
-     * Apply Integer option with fallback logic.
+     * Apply Integer option as Double with fallback logic.
      */
-    private void applyIntegerOption(
-            java.util.function.Function<GenerateOptions, Integer> accessor,
+    private void applyIntegerAsDoubleOption(
+            Function<GenerateOptions, Integer> accessor,
             GenerateOptions options,
             GenerateOptions defaultOptions,
-            java.util.function.Consumer<Integer> setter) {
+            Consumer<Double> setter) {
 
         Integer value = getOptionOrDefault(options, defaultOptions, accessor);
         if (value != null) {
-            setter.accept(value);
+            setter.accept(value.doubleValue());
         }
     }
 
     /**
-     * Apply Integer option as Float with fallback logic (for Gemini topK which requires Float).
+     * Apply Long option as Integer with fallback logic.
      */
-    private void applyIntegerAsFloatOption(
-            java.util.function.Function<GenerateOptions, Integer> accessor,
+    private void applyLongAsIntegerOption(
+            Function<GenerateOptions, Long> accessor,
             GenerateOptions options,
             GenerateOptions defaultOptions,
-            java.util.function.Consumer<Float> setter) {
+            Consumer<Integer> setter) {
 
-        Integer value = getOptionOrDefault(options, defaultOptions, accessor);
+        Long value = getOptionOrDefault(options, defaultOptions, accessor);
         if (value != null) {
-            setter.accept(value.floatValue());
+            setter.accept(value.intValue());
         }
     }
 
     /**
-     * Apply Long option as Integer with fallback logic (for Gemini seed which requires Integer).
+     * Apply Integer option with fallback logic.
      */
-    private void applyLongAsIntOption(
-            java.util.function.Function<GenerateOptions, Long> accessor,
+    private void applyIntegerOption(
+            Function<GenerateOptions, Integer> accessor,
             GenerateOptions options,
             GenerateOptions defaultOptions,
-            java.util.function.Consumer<Integer> setter) {
+            Consumer<Integer> setter) {
 
-        Long value = getOptionOrDefault(options, defaultOptions, accessor);
+        Integer value = getOptionOrDefault(options, defaultOptions, accessor);
         if (value != null) {
-            setter.accept(value.intValue());
+            setter.accept(value);
         }
     }
 
     @Override
-    public void applyTools(GenerateContentConfig.Builder configBuilder, List<ToolSchema> tools) {
-        Tool tool = toolsHelper.convertToGeminiTool(tools);
+    public void applyTools(GeminiRequest request, List<ToolSchema> tools) {
+        GeminiTool tool = toolsHelper.convertToGeminiTool(tools);
         if (tool != null) {
-            configBuilder.tools(List.of(tool));
+            // Gemini API expects a list of tools, typically one tool object containing
+            // function declarations
+            request.setTools(List.of(tool));
         }
     }
 
     @Override
-    public void applyToolChoice(
-            GenerateContentConfig.Builder configBuilder, ToolChoice toolChoice) {
-        ToolConfig toolConfig = toolsHelper.convertToolChoice(toolChoice);
+    public void applyToolChoice(GeminiRequest request, ToolChoice toolChoice) {
+        GeminiToolConfig toolConfig = toolsHelper.convertToolChoice(toolChoice);
         if (toolConfig != null) {
-            configBuilder.toolConfig(toolConfig);
+            request.setToolConfig(toolConfig);
         }
     }
 }