@pheem49/mint 1.6.2 → 1.6.4

package/crates/mint-cli/src/onboard.rs

@@ -60,6 +60,24 @@ const HUGGINGFACE_MODEL_PRESETS: &[&str] = &[
     "google/gemma-3-27b-it",
 ];
 
+// ── Image Generation Providers ──────────────────────────────────────────────
+const NANOBANANA_IMAGE_MODEL_PRESETS: &[&str] =
+    &["gemini-2.5-flash-image", "gemini-2.0-flash-image"];
+
+const DALLE_MODEL_PRESETS: &[&str] = &["dall-e-3", "gpt-image-1", "dall-e-2"];
+
+const STABILITY_MODEL_PRESETS: &[&str] =
+    &["sd3.5-large", "sd3.5-large-turbo", "sd3-medium", "core"];
+
+const IDEOGRAM_MODEL_PRESETS: &[&str] = &["V_3", "V_2", "V_2_TURBO"];
+
+const REPLICATE_MODEL_PRESETS: &[&str] = &[
+    "black-forest-labs/flux-1.1-pro",
+    "black-forest-labs/flux-schnell",
+    "stability-ai/sdxl",
+    "bytedance/sdxl-lightning-4step",
+];
+
 pub async fn run() -> Result<()> {
     let mut config = load_config()?;
 
@@ -231,6 +249,37 @@ pub async fn run() -> Result<()> {
                 .and_then(|v| v.as_bool())
                 .unwrap_or(false),
         },
+        // ── Image Generation ─────────────────────────────────────────────────
+        OnboardService {
+            category: "Image Generation",
+            name: "Google NanoBanana (Gemini Images)  [uses Gemini key]",
+            key: "img_nanobanana",
+            enabled: !config.api_key.is_empty() && !config.nanobanana_model.is_empty(),
+        },
+        OnboardService {
+            category: "Image Generation",
+            name: "OpenAI DALL·E  [uses OpenAI key]",
+            key: "img_dalle",
+            enabled: !config.openai_api_key.is_empty() && !config.dalle_model.is_empty(),
+        },
+        OnboardService {
+            category: "Image Generation",
+            name: "Stability AI (Stable Diffusion)",
+            key: "img_stability",
+            enabled: !config.stability_api_key.is_empty(),
+        },
+        OnboardService {
+            category: "Image Generation",
+            name: "Ideogram v3",
+            key: "img_ideogram",
+            enabled: !config.ideogram_api_key.is_empty(),
+        },
+        OnboardService {
+            category: "Image Generation",
+            name: "Replicate (FLUX / SDXL / custom)",
+            key: "img_replicate",
+            enabled: !config.replicate_api_key.is_empty(),
+        },
     ];
 
     let mut cursor = 0;
@@ -842,7 +891,91 @@ pub async fn run() -> Result<()> {
         );
     }
 
-    println!();
+    // ────────────────────────────────────────────────────────────────────────
+    // Image Generation providers
+    // ────────────────────────────────────────────────────────────────────────
+
+    // NanoBanana (Gemini Images)
+    if is_selected("img_nanobanana", &services) {
+        println!("\n\x1b[36m--- Google NanoBanana (Gemini Images) ---\x1b[0m");
+        println!(
+            "\x1b[90mUses the same Gemini API key as Step 1. Select the image generation model.\x1b[0m"
+        );
+        config.nanobanana_model = prompt_select_or_custom(
+            "NanoBanana Model",
+            static_model_options(NANOBANANA_IMAGE_MODEL_PRESETS),
+            Some(&config.nanobanana_model),
+            "Custom NanoBanana model...",
+        )?;
+    }
+
+    // DALL·E
+    if is_selected("img_dalle", &services) {
+        println!("\n\x1b[36m--- OpenAI DALL·E ---\x1b[0m");
+        println!(
+            "\x1b[90mUses the same OpenAI API key. DALL·E 3 supports only 1 image per request; DALL·E 2 supports up to 10.\x1b[0m"
+        );
+        config.dalle_model = prompt_select_or_custom(
+            "DALL·E Model",
+            static_model_options(DALLE_MODEL_PRESETS),
+            Some(&config.dalle_model),
+            "Custom DALL·E model...",
+        )?;
+    }
+
+    // Stability AI
+    if is_selected("img_stability", &services) {
+        println!("\n\x1b[36m--- Stability AI ---\x1b[0m");
+        println!(
+            "\x1b[90mGet your API key at https://platform.stability.ai/. Supports SD3.5 Large, SD3 Medium, and Stable Image Core.\x1b[0m"
+        );
+        config.stability_api_key =
+            prompt_sensitive("Stability AI API Key", &config.stability_api_key)?;
+        config.stability_model = prompt_select_or_custom(
+            "Stability Model",
+            static_model_options(STABILITY_MODEL_PRESETS),
+            Some(&config.stability_model),
+            "Custom Stability model...",
+        )?;
+    } else {
+        config.stability_api_key = String::new();
+    }
+
+    // Ideogram
+    if is_selected("img_ideogram", &services) {
+        println!("\n\x1b[36m--- Ideogram ---\x1b[0m");
+        println!(
+            "\x1b[90mGet your API key at https://ideogram.ai/api. Supports V_3, V_2, and V_2_TURBO.\x1b[0m"
+        );
+        config.ideogram_api_key = prompt_sensitive("Ideogram API Key", &config.ideogram_api_key)?;
+        config.ideogram_model = prompt_select_or_custom(
+            "Ideogram Model",
+            static_model_options(IDEOGRAM_MODEL_PRESETS),
+            Some(&config.ideogram_model),
+            "Custom Ideogram model...",
+        )?;
+    } else {
+        config.ideogram_api_key = String::new();
+    }
+
+    // Replicate
+    if is_selected("img_replicate", &services) {
+        println!("\n\x1b[36m--- Replicate ---\x1b[0m");
+        println!(
+            "\x1b[90mGet your API token at https://replicate.com/account/api-tokens. Works with FLUX, SDXL, and any public image model.\x1b[0m"
+        );
+        config.replicate_api_key =
+            prompt_sensitive("Replicate API Token", &config.replicate_api_key)?;
+        config.replicate_model = prompt_select_or_custom(
+            "Replicate Model (owner/model-name)",
+            static_model_options(REPLICATE_MODEL_PRESETS),
+            Some(&config.replicate_model),
+            "Custom Replicate model...",
+        )?;
+    } else {
+        config.replicate_api_key = String::new();
+    }
+
     save_config(&config)?;
     println!("\x1b[32m✅ Configuration saved successfully!\x1b[0m");
     Ok(())

package/crates/mint-core/src/api_server.rs

@@ -11,9 +11,10 @@ use tokio::net::TcpListener;
 
 use crate::{
     AgentProgress, ApprovalOutcome, ChatRequest, ChatResponse, DEFAULT_CONVERSATION_ID,
-    MemoryStore, MintConfig, config_path, create_folder, find_paths, list_saved_pictures,
-    load_config, orchestrate_agent_loop, orchestrate_chat_stream_with_fallback,
-    orchestrate_chat_with_fallback, save_chat_images, save_config, weather,
+    ImageGenRequest, MemoryStore, MintConfig, config_path, create_folder, find_paths,
+    generate_images, list_saved_pictures, load_config, orchestrate_agent_loop,
+    orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback, save_chat_images,
+    save_config, weather,
 };
 
 const MAX_API_REQUEST_BYTES: usize = 32 * 1024 * 1024;
@@ -663,6 +664,110 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
+                ("POST", "/api/image-generate") => {
+                    #[derive(serde::Deserialize)]
+                    #[serde(rename_all = "camelCase")]
+                    struct ImageGenApiRequest {
+                        prompt: String,
+                        #[serde(default)]
+                        negative_prompt: Option<String>,
+                        #[serde(default)]
+                        aspect_ratio: Option<String>,
+                        #[serde(default)]
+                        num_images: Option<u8>,
+                        #[serde(default)]
+                        model: Option<String>,
+                        /// Which image provider to use (overrides config.image_gen_provider).
+                        #[serde(default)]
+                        provider: Option<String>,
+                    }
+
+                    if let Ok(req) = serde_json::from_str::<ImageGenApiRequest>(body) {
+                        let config = load_config().unwrap_or_default();
+                        let gen_request = ImageGenRequest {
+                            prompt: req.prompt.clone(),
+                            negative_prompt: req.negative_prompt,
+                            aspect_ratio: req.aspect_ratio,
+                            num_images: req.num_images,
+                            model: req.model,
+                            provider: req.provider,
+                        };
+                        match generate_images(&config, &gen_request).await {
+                            Ok(result) => {
+                                let data_uris: Vec<String> = result
+                                    .images
+                                    .iter()
+                                    .map(|img| img.data_uri.clone())
+                                    .collect();
+                                let mut saved = save_chat_images(
+                                    data_uris,
+                                    Some(result.provider.clone()),
+                                    Some(req.prompt.clone()),
+                                )
+                                .unwrap_or_default();
+                                for picture in &mut saved {
+                                    picture.url =
+                                        Some(format!("/api/pictures/{}", picture.filename));
+                                    picture.thumbnail_url =
+                                        Some(format!("/api/pictures/{}", picture.filename));
+                                }
+                                let response = json!({
+                                    "images": saved,
+                                    "model": result.model,
+                                    "provider": result.provider,
+                                    "prompt": result.prompt,
+                                    "description": result.description
+                                });
+                                send_json_response(socket, "200 OK", &response.to_string()).await;
+                            }
+                            Err(e) => {
+                                let err = json!({ "error": e.to_string() });
+                                send_json_response(
+                                    socket,
+                                    "500 Internal Server Error",
+                                    &err.to_string(),
+                                )
+                                .await;
+                            }
+                        }
+                    } else {
+                        send_json_response(
+                            socket,
+                            "400 Bad Request",
+                            "{\"error\":\"invalid image generation request body\"}",
+                        )
+                        .await;
+                    }
+                }
+                ("GET", "/api/image-gen/providers") => {
+                    let config = load_config().unwrap_or_default();
+                    let mut available: Vec<String> = Vec::new();
+                    if !config.api_key.trim().is_empty() {
+                        available.push("nanobanana".into());
+                    }
+                    if !config.openai_api_key.trim().is_empty() {
+                        available.push("dalle".into());
+                    }
+                    if !config.stability_api_key.trim().is_empty() {
+                        available.push("stability".into());
+                    }
+                    if !config.ideogram_api_key.trim().is_empty() {
+                        available.push("ideogram".into());
+                    }
+                    if !config.replicate_api_key.trim().is_empty() {
+                        available.push("replicate".into());
+                    }
+                    let active = if available.contains(&config.image_gen_provider) {
+                        config.image_gen_provider.clone()
+                    } else {
+                        available
+                            .first()
+                            .cloned()
+                            .unwrap_or_else(|| "nanobanana".into())
+                    };
+                    let response = json!({ "active": active, "available": available });
+                    send_json_response(socket, "200 OK", &response.to_string()).await;
+                }
                 _ => {
                     send_json_response(socket, "404 Not Found", "{\"error\":\"Not Found\"}").await;
                 }

package/crates/mint-core/src/config.rs

@@ -60,6 +60,16 @@ pub struct MintConfig {
     pub local_model_name: String,
     pub ollama_host: String,
     pub ollama_model: String,
+    pub nanobanana_model: String,
+    /// Active image-generation provider: "nanobanana" | "dalle" | "stability" | "ideogram" | "replicate"
+    pub image_gen_provider: String,
+    pub dalle_model: String,
+    pub stability_api_key: String,
+    pub stability_model: String,
+    pub ideogram_api_key: String,
+    pub ideogram_model: String,
+    pub replicate_api_key: String,
+    pub replicate_model: String,
     pub show_desktop_widget: bool,
     pub safety_enabled: bool,
     pub sandbox_mode: String,
@@ -89,7 +99,7 @@ impl Default for MintConfig {
         ];
         Self {
             theme: "dark".into(),
-            accent_color: "#8b5cf6".into(),
+            accent_color: "#10b981".into(),
             language: "th-TH".into(),
             assistant_mode: "chat".into(),
             ai_provider: "gemini".into(),
@@ -109,6 +119,15 @@ impl Default for MintConfig {
             local_model_name: "local-model".into(),
             ollama_host: String::new(),
             ollama_model: "llama3:latest".into(),
+            nanobanana_model: "gemini-2.5-flash-image".into(),
+            image_gen_provider: "nanobanana".into(),
+            dalle_model: "dall-e-3".into(),
+            stability_api_key: String::new(),
+            stability_model: "sd3.5-large".into(),
+            ideogram_api_key: String::new(),
+            ideogram_model: "V_3".into(),
+            replicate_api_key: String::new(),
+            replicate_model: "black-forest-labs/flux-1.1-pro".into(),
             show_desktop_widget: true,
             safety_enabled: true,
             sandbox_mode: "prefer".into(),