Integrated iFlow LLM provider

LeaderOnePro · LeaderOnePro · commit fd6bcadc7bd8 · 2026-02-02T07:10:35.000+08:00
diff --git a/README.md b/README.md
@@ -27,7 +27,7 @@ The agents aren't following predefined scripts. They're operating off natural la
 **You need:**
 - Minecraft 1.20.1 with Forge
 - Java 17
-- An LLM API key (LongCat, DeepSeek, OpenAI GPT-5, Gemini 3, or Groq)
+- An LLM API key (LongCat, iFlow, DeepSeek, OpenAI GPT-5, Gemini 3, or Groq)
 
 **Installation:**
 1. Download the JAR from releases
@@ -83,7 +83,7 @@ Each Steve runs an autonomous agent loop that processes natural language command
 ### Core Components
 
 **LLM Integration** (`com.steve.ai.llm`)
-- **Multi-Provider Support**: Pluggable clients for LongCat, DeepSeek, OpenAI, Gemini, and Groq.
+- **Multi-Provider Support**: Pluggable clients for LongCat, iFlow, DeepSeek, OpenAI, Gemini, and Groq.
 - **Resilient Clients**: Async implementations with caching, retries, and circuit breaker patterns.
 - **TaskPlanner**: Orchestrates LLM calls with context (conversation history, world state, Steve capabilities)
 - **PromptBuilder**: Constructs prompts with available actions, examples, and formatting instructions
@@ -236,7 +236,7 @@ Edit `config/steve-common.toml`. Each provider now has its own section for bette
 
 ```toml
 [ai]
-provider = "longcat"  # Options: longcat, deepseek, openai, gemini, groq
+provider = "longcat"  # Options: longcat, iflow, deepseek, openai, gemini, groq
 maxTokens = 8000
 temperature = 0.7
 
diff --git a/config/steve-common.toml.example b/config/steve-common.toml.example
@@ -1,6 +1,6 @@
 # AI Provider Configuration
 [ai]
-    # AI provider to use: 'longcat', 'deepseek', 'openai', 'gemini', or 'groq'
+    # AI provider to use: 'longcat', 'iflow', 'deepseek', 'openai', 'gemini', or 'groq'
     provider = "longcat"
     
     # Maximum tokens per API request (applies to all LLM providers)
@@ -17,6 +17,14 @@
     
     # LongCat model to use (LongCat-Flash-Chat, LongCat-Flash-Thinking, LongCat-Flash-Thinking-2601)
     model = "LongCat-Flash-Thinking-2601"
+    
+# iFlow API Configuration
+[iflow]
+    # Your iFlow API key (get from: https://platform.iflow.cn/profile?tab=apiKey)
+    apiKey = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    
+    # iFlow model to use (glm-4.6, kimi-k2, qwen3-coder-plus, qwen3-max, qwen3-vl-plus, deepseek-v3.2, tstars2.0, iflow-rome-30ba3b)
+    model = "glm-4.6"
 
 # DeepSeek API Configuration
 [deepseek]
diff --git a/src/main/java/com/steve/ai/config/SteveConfig.java b/src/main/java/com/steve/ai/config/SteveConfig.java
@@ -14,6 +14,10 @@ public class SteveConfig {
     public static final ForgeConfigSpec.ConfigValue<String> LONGCAT_API_KEY;
     public static final ForgeConfigSpec.ConfigValue<String> LONGCAT_MODEL;
 
+    // iFlow
+    public static final ForgeConfigSpec.ConfigValue<String> IFLOW_API_KEY;
+    public static final ForgeConfigSpec.ConfigValue<String> IFLOW_MODEL;
+
     // DeepSeek
     public static final ForgeConfigSpec.ConfigValue<String> DEEPSEEK_API_KEY;
     public static final ForgeConfigSpec.ConfigValue<String> DEEPSEEK_MODEL;
@@ -41,7 +45,7 @@ public class SteveConfig {
         builder.comment("AI API Configuration").push("ai");
         
         AI_PROVIDER = builder
-            .comment("AI provider to use: 'longcat', 'deepseek', 'openai', 'gemini', or 'groq' (FASTEST, FREE)")
+            .comment("AI provider to use: 'longcat', 'iflow', 'deepseek', 'openai', 'gemini', or 'groq' (FASTEST, FREE)")
             .define("provider", "longcat");
         
         MAX_TOKENS = builder
@@ -66,6 +70,19 @@ public class SteveConfig {
         
         builder.pop();
 
+
+        builder.comment("iFlow API Configuration").push("iflow");
+        
+        IFLOW_API_KEY = builder
+            .comment("Your iFlow API key (get from: https://platform.iflow.cn/profile?tab=apiKey)")
+            .define("apiKey", "");
+        
+        IFLOW_MODEL = builder
+            .comment("iFlow model to use (glm-4.6, kimi-k2, qwen3-coder-plus, qwen3-max, qwen3-vl-plus, deepseek-v3.2, tstars2.0, iflow-rome-30ba3b)")
+            .define("model", "glm-4.6");
+        
+        builder.pop();
+
         builder.comment("DeepSeek API Configuration").push("deepseek");
         
         DEEPSEEK_API_KEY = builder
diff --git a/src/main/java/com/steve/ai/llm/IFlowClient.java b/src/main/java/com/steve/ai/llm/IFlowClient.java
@@ -0,0 +1,125 @@
+package com.steve.ai.llm;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.steve.ai.SteveMod;
+import com.steve.ai.config.SteveConfig;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+
+/**
+ * Client for iFlow API - OpenAI-compatible
+ * Endpoint: https://apis.iflow.cn/v1/chat/completions
+ * API Keys: https://platform.iflow.cn/profile?tab=apiKey
+ */
+public class IFlowClient {
+    private static final String IFLOW_API_URL = "https://apis.iflow.cn/v1/chat/completions";
+    private static final int MAX_RETRIES = 3;
+    private static final int INITIAL_RETRY_DELAY_MS = 1000;
+
+    private final HttpClient client;
+    private final String apiKey;
+
+    public IFlowClient() {
+        this.apiKey = SteveConfig.IFLOW_API_KEY.get();
+        this.client = HttpClient.newBuilder()
+            .connectTimeout(Duration.ofSeconds(30))
+            .build();
+    }
+
+    public String sendRequest(String systemPrompt, String userPrompt) {
+        if (apiKey == null || apiKey.isEmpty()) {
+            SteveMod.LOGGER.error("iFlow API key not configured!");
+            return null;
+        }
+
+        JsonObject requestBody = buildRequestBody(systemPrompt, userPrompt);
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(URI.create(IFLOW_API_URL))
+            .header("Authorization", "Bearer " + apiKey)
+            .header("Content-Type", "application/json")
+            .timeout(Duration.ofSeconds(60))
+            .POST(HttpRequest.BodyPublishers.ofString(requestBody.toString()))
+            .build();
+
+        for (int attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            try {
+                HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+                if (response.statusCode() == 200) {
+                    return parseResponse(response.body());
+                }
+
+                if (response.statusCode() == 429 || response.statusCode() >= 500) {
+                    if (attempt < MAX_RETRIES - 1) {
+                        long delayMs = (long) INITIAL_RETRY_DELAY_MS * (int) Math.pow(2, attempt);
+                        SteveMod.LOGGER.warn("iFlow API failed ({}), retrying in {}ms", response.statusCode(), delayMs);
+                        try {
+                            Thread.sleep(delayMs);
+                        } catch (InterruptedException ie) {
+                            Thread.currentThread().interrupt();
+                            return null;
+                        }
+                        continue;
+                    }
+                }
+
+                SteveMod.LOGGER.error("iFlow API request failed: {}", response.statusCode());
+                return null;
+            } catch (Exception e) {
+                if (attempt < MAX_RETRIES - 1) {
+                    long delayMs = (long) INITIAL_RETRY_DELAY_MS * (int) Math.pow(2, attempt);
+                    SteveMod.LOGGER.warn("Error communicating with iFlow API, retrying in {}ms", delayMs, e);
+                    try {
+                        Thread.sleep(delayMs);
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
+                        return null;
+                    }
+                } else {
+                    SteveMod.LOGGER.error("Error communicating with iFlow API after {} attempts", MAX_RETRIES, e);
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+
+    private JsonObject buildRequestBody(String systemPrompt, String userPrompt) {
+        JsonObject body = new JsonObject();
+        body.addProperty("model", SteveConfig.IFLOW_MODEL.get());
+        body.addProperty("temperature", SteveConfig.TEMPERATURE.get());
+        body.addProperty("max_tokens", SteveConfig.MAX_TOKENS.get());
+
+        JsonArray messages = new JsonArray();
+        JsonObject systemMessage = new JsonObject();
+        systemMessage.addProperty("role", "system");
+        systemMessage.addProperty("content", systemPrompt);
+        messages.add(systemMessage);
+
+        JsonObject userMessage = new JsonObject();
+        userMessage.addProperty("role", "user");
+        userMessage.addProperty("content", userPrompt);
+        messages.add(userMessage);
+
+        body.add("messages", messages);
+        return body;
+    }
+
+    private String parseResponse(String responseBody) {
+        try {
+            JsonObject json = JsonParser.parseString(responseBody).getAsJsonObject();
+            return json.getAsJsonArray("choices").get(0).getAsJsonObject()
+                .getAsJsonObject("message").get("content").getAsString();
+        } catch (Exception e) {
+            SteveMod.LOGGER.error("Error parsing iFlow response", e);
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/steve/ai/llm/TaskPlanner.java b/src/main/java/com/steve/ai/llm/TaskPlanner.java
@@ -16,13 +16,15 @@
 public class TaskPlanner {
     // Legacy synchronous clients (for backward compatibility)
     private final LongCatClient longCatClient;
+    private final IFlowClient iflowClient;
     private final DeepSeekClient deepSeekClient;
     private final OpenAIClient openAIClient;
     private final GeminiClient geminiClient;
     private final GroqClient groqClient;
 
     // NEW: Async resilient clients
     private final AsyncLLMClient asyncLongCatClient;
+    private final AsyncLLMClient asyncIFlowClient;
     private final AsyncLLMClient asyncDeepSeekClient;
     private final AsyncLLMClient asyncOpenAIClient;
     private final AsyncLLMClient asyncGeminiClient;
@@ -33,6 +35,7 @@ public class TaskPlanner {
     public TaskPlanner() {
         // Legacy clients (always initialize - these work without external dependencies)
         this.longCatClient = new LongCatClient();
+        this.iflowClient = new IFlowClient();
         this.deepSeekClient = new DeepSeekClient();
         this.openAIClient = new OpenAIClient();
         this.geminiClient = new GeminiClient();
@@ -42,6 +45,7 @@ public TaskPlanner() {
         LLMCache tempCache = null;
         LLMFallbackHandler tempFallback = null;
         AsyncLLMClient tempAsyncLongCat = null;
+        AsyncLLMClient tempAsyncIFlow = null;
         AsyncLLMClient tempAsyncDeepSeek = null;
         AsyncLLMClient tempAsyncOpenAI = null;
         AsyncLLMClient tempAsyncGemini = null;
@@ -63,6 +67,13 @@ public TaskPlanner() {
                 temperature
             );
 
+            AsyncLLMClient baseIFlow = new AsyncIFlowClient(
+                SteveConfig.IFLOW_API_KEY.get(),
+                SteveConfig.IFLOW_MODEL.get(),
+                maxTokens,
+                temperature
+            );
+
             AsyncLLMClient baseDeepSeek = new AsyncDeepSeekClient(
                 SteveConfig.DEEPSEEK_API_KEY.get(),
                 SteveConfig.DEEPSEEK_MODEL.get(),
@@ -93,6 +104,7 @@ public TaskPlanner() {
 
             // Wrap with resilience patterns (caching, retries, circuit breaker)
             tempAsyncLongCat = new ResilientLLMClient(baseLongCat, tempCache, tempFallback);
+            tempAsyncIFlow = new ResilientLLMClient(baseIFlow, tempCache, tempFallback);
             tempAsyncDeepSeek = new ResilientLLMClient(baseDeepSeek, tempCache, tempFallback);
             tempAsyncOpenAI = new ResilientLLMClient(baseOpenAI, tempCache, tempFallback);
             tempAsyncGemini = new ResilientLLMClient(baseGemini, tempCache, tempFallback);
@@ -106,6 +118,7 @@ public TaskPlanner() {
         this.llmCache = tempCache;
         this.fallbackHandler = tempFallback;
         this.asyncLongCatClient = tempAsyncLongCat;
+        this.asyncIFlowClient = tempAsyncIFlow;
         this.asyncDeepSeekClient = tempAsyncDeepSeek;
         this.asyncOpenAIClient = tempAsyncOpenAI;
         this.asyncGeminiClient = tempAsyncGemini;
@@ -146,6 +159,7 @@ public ResponseParser.ParsedResponse planTasks(SteveEntity steve, String command
     private String getAIResponse(String provider, String systemPrompt, String userPrompt) {
         String response = switch (provider) {
             case "longcat" -> longCatClient.sendRequest(systemPrompt, userPrompt);
+            case "iflow" -> iflowClient.sendRequest(systemPrompt, userPrompt);
             case "deepseek" -> deepSeekClient.sendRequest(systemPrompt, userPrompt);
             case "openai" -> openAIClient.sendRequest(systemPrompt, userPrompt);
             case "gemini" -> geminiClient.sendRequest(systemPrompt, userPrompt);
@@ -193,6 +207,7 @@ public CompletableFuture<ResponseParser.ParsedResponse> planTasksAsync(SteveEnti
             // Build params map with provider-specific model
             String modelForProvider = switch (provider) {
                 case "longcat" -> SteveConfig.LONGCAT_MODEL.get();
+                case "iflow" -> SteveConfig.IFLOW_MODEL.get();
                 case "deepseek" -> SteveConfig.DEEPSEEK_MODEL.get();
                 case "openai" -> SteveConfig.OPENAI_MODEL.get();
                 case "gemini" -> SteveConfig.GEMINI_MODEL.get();
@@ -276,6 +291,7 @@ public CompletableFuture<ResponseParser.ParsedResponse> planTasksAsync(SteveEnti
     private AsyncLLMClient getAsyncClient(String provider) {
         AsyncLLMClient client = switch (provider) {
             case "longcat" -> asyncLongCatClient;
+            case "iflow" -> asyncIFlowClient;
             case "deepseek" -> asyncDeepSeekClient;
             case "openai" -> asyncOpenAIClient;
             case "gemini" -> asyncGeminiClient;
@@ -289,8 +305,9 @@ private AsyncLLMClient getAsyncClient(String provider) {
         // Null check - if preferred client is null, try fallback options
         if (client == null) {
             SteveMod.LOGGER.warn("[Async] Client for provider '{}' is null, trying fallbacks", provider);
-            // Try fallback order: longcat -> deepseek -> openai -> gemini -> groq
+            // Try fallback order: longcat -> iflow -> deepseek -> openai -> gemini -> groq
             if (asyncLongCatClient != null) return asyncLongCatClient;
+            if (asyncIFlowClient != null) return asyncIFlowClient;
             if (asyncDeepSeekClient != null) return asyncDeepSeekClient;
             if (asyncOpenAIClient != null) return asyncOpenAIClient;
             if (asyncGeminiClient != null) return asyncGeminiClient;
diff --git a/src/main/java/com/steve/ai/llm/async/AsyncIFlowClient.java b/src/main/java/com/steve/ai/llm/async/AsyncIFlowClient.java
