@pheem49/mint 1.6.3 → 1.7.0

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-cli/src/setup.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use crossterm::event::{self, Event, KeyCode};
 use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
-use mint_core::{load_config, save_config};
+use mint_core::{load_config, save_config, native_plugins};
 use std::io::{self, Write};
 
 struct ToolOption {
@@ -13,15 +13,6 @@ struct ToolOption {
 pub async fn run() -> Result<Option<String>> {
     let mut config = load_config()?;
 
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("\x1b[32m       Mint CLI Tool Manager Wizard\x1b[0m");
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("Configure which agent tools are enabled or disabled:");
-    println!(
-        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
-    );
-    println!();
-
     let mut options = vec![
         ToolOption {
             name: "list_files (List Workspace Files)",
@@ -178,7 +169,7 @@ pub async fn run() -> Result<Option<String>> {
     ];
 
     let mut cursor = 0;
-    print_options(&options, cursor);
+    redraw_phase_1(&options, cursor);
     enable_raw_mode()?;
 
     loop {
@@ -204,8 +195,7 @@ pub async fn run() -> Result<Option<String>> {
                                     cursor = options.len() - 1;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Down => {
@@ -215,15 +205,13 @@ pub async fn run() -> Result<Option<String>> {
                                     cursor = 0;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char(' ') => {
                                 options[cursor].enabled = !options[cursor].enabled;
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char('a') => {
@@ -231,8 +219,7 @@ pub async fn run() -> Result<Option<String>> {
                                     opt.enabled = true;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char('i') => {
@@ -240,8 +227,7 @@ pub async fn run() -> Result<Option<String>> {
                                     opt.enabled = !opt.enabled;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Enter => {
@@ -270,15 +256,135 @@ pub async fn run() -> Result<Option<String>> {
     config.disabled_tools = disabled;
     save_config(&config)?;
 
-    println!("\x1b[32mSuccessfully updated tool configurations!\x1b[0m\n");
+    println!("\x1b[32mSuccessfully updated agent tool configurations!\x1b[0m\n");
 
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("\x1b[32m       Choose where to run Mint AI Agent\x1b[0m");
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("Select the environment you want to launch:");
-    println!("  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Enter: Confirm]\x1b[0m");
+    let all_native = native_plugins();
+    let allowed_plugins: std::collections::HashSet<String> = config
+        .extra
+        .get("allowedNativePlugins")
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                .collect()
+        })
+        .unwrap_or_else(|| {
+            vec![
+                "dev_tools".to_string(),
+                "system_metrics".to_string(),
+                "github".to_string(),
+            ]
+            .into_iter()
+            .collect()
+        });
+
+    let mut native_options: Vec<ToolOption> = all_native
+        .iter()
+        .map(|p| {
+            let has_all_permission = allowed_plugins.contains("*");
+            let is_enabled = has_all_permission || allowed_plugins.contains(p.name);
+            ToolOption {
+                name: p.name,
+                key: p.name,
+                enabled: is_enabled,
+            }
+        })
+        .collect();
+
+    let mut native_cursor = 0;
+    redraw_phase_2(&native_options, native_cursor);
+    enable_raw_mode()?;
+
+    loop {
+        match event::poll(std::time::Duration::from_millis(100)) {
+            Ok(true) => {
+                if let Event::Key(key_event) = event::read()? {
+                    if key_event.kind == event::KeyEventKind::Press {
+                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                            && key_event
+                                .modifiers
+                                .contains(crossterm::event::KeyModifiers::CONTROL);
+                        if is_ctrl_c {
+                            disable_raw_mode()?;
+                            println!("\n\x1b[31mSetup cancelled.\x1b[0m");
+                            return Ok(None);
+                        }
+
+                        match key_event.code {
+                            KeyCode::Up => {
+                                if native_cursor > 0 {
+                                    native_cursor -= 1;
+                                } else {
+                                    native_cursor = native_options.len() - 1;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Down => {
+                                if native_cursor < native_options.len() - 1 {
+                                    native_cursor += 1;
+                                } else {
+                                    native_cursor = 0;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char(' ') => {
+                                native_options[native_cursor].enabled =
+                                    !native_options[native_cursor].enabled;
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('a') => {
+                                for opt in &mut native_options {
+                                    opt.enabled = true;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('i') => {
+                                for opt in &mut native_options {
+                                    opt.enabled = !opt.enabled;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Enter => {
+                                break;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            Ok(false) => {}
+            Err(_) => {
+                break;
+            }
+        }
+    }
+    disable_raw_mode()?;
     println!();
 
+    let enabled_natives: Vec<serde_json::Value> = native_options
+        .iter()
+        .filter(|o| o.enabled)
+        .map(|o| serde_json::Value::String(o.key.to_string()))
+        .collect();
+
+    config.extra.insert(
+        "allowedNativePlugins".to_string(),
+        serde_json::Value::Array(enabled_natives),
+    );
+    save_config(&config)?;
+
+    println!("\x1b[32mSuccessfully updated native plugins configurations!\x1b[0m\n");
+
     let run_options = vec![
         ToolOption {
             name: "1. CLI (Interactive Terminal Assistant)",
@@ -298,7 +404,7 @@ pub async fn run() -> Result<Option<String>> {
     ];
 
     let mut run_cursor = 0;
-    print_run_options(&run_options, run_cursor);
+    redraw_phase_3(&run_options, run_cursor);
     enable_raw_mode()?;
 
     loop {
@@ -324,8 +430,7 @@ pub async fn run() -> Result<Option<String>> {
                                     run_cursor = run_options.len() - 1;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", run_options.len());
-                                print_run_options(&run_options, run_cursor);
+                                redraw_phase_3(&run_options, run_cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Down => {
@@ -335,8 +440,7 @@ pub async fn run() -> Result<Option<String>> {
                                     run_cursor = 0;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", run_options.len());
-                                print_run_options(&run_options, run_cursor);
+                                redraw_phase_3(&run_options, run_cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Enter => {
@@ -388,3 +492,40 @@ fn print_run_options(options: &[ToolOption], cursor: usize) {
     }
     let _ = io::stdout().flush();
 }
+
+fn redraw_phase_1(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Mint CLI Tool Manager Wizard\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Configure which agent tools are enabled or disabled:");
+    println!(
+        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
+    );
+    println!();
+    print_options(options, cursor);
+}
+
+fn redraw_phase_2(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Configure Native Plugins Access\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Select which native plugins are allowed to run:");
+    println!(
+        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
+    );
+    println!();
+    print_options(options, cursor);
+}
+
+fn redraw_phase_3(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Choose where to run Mint AI Agent\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Select the environment you want to launch:");
+    println!("  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Enter: Confirm]\x1b[0m");
+    println!();
+    print_run_options(options, cursor);
+}

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;
@@ -271,6 +272,45 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         .await;
                     }
                 }
+                ("POST", "/api/interactions/agent-activity") => {
+                    #[derive(Deserialize)]
+                    #[serde(rename_all = "camelCase")]
+                    struct SaveAgentActivityRequest {
+                        interaction_id: i64,
+                        activity: Vec<AgentProgress>,
+                    }
+
+                    if let Ok(payload) = serde_json::from_str::<SaveAgentActivityRequest>(body) {
+                        if let Ok(memory) = MemoryStore::open_default() {
+                            match serde_json::to_string(&payload.activity) {
+                                Ok(activity_json) => {
+                                    if memory
+                                        .set_interaction_agent_activity_json(
+                                            payload.interaction_id,
+                                            &activity_json,
+                                        )
+                                        .is_ok()
+                                    {
+                                        send_json_response(
+                                            socket,
+                                            "200 OK",
+                                            "{\"status\":\"ok\"}",
+                                        )
+                                        .await;
+                                        return;
+                                    }
+                                }
+                                Err(_) => {}
+                            }
+                        }
+                    }
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        "{\"status\":\"invalid agent activity payload\"}",
+                    )
+                    .await;
+                }
                 ("GET", "/api/pictures") => match list_saved_pictures() {
                     Ok(mut pictures) => {
                         for picture in &mut pictures {
@@ -663,6 +703,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(),
@@ -291,7 +310,7 @@ fn runtime_extra_defaults() -> BTreeMap<String, Value> {
         "notionPageId": "",
         "notionTitleProperty": "Name",
         "allowedShellModes": ["readOnly", "test", "mutating", "network"],
-        "allowedNativePlugins": ["dev_tools", "system_metrics"],
+        "allowedNativePlugins": ["dev_tools", "system_metrics", "github"],
         "allowedMcpTools": {},
         "mcpServers": {}
     }))
@@ -361,7 +380,7 @@ mod tests {
         );
         assert_eq!(
             config.extra["allowedNativePlugins"],
-            serde_json::json!(["dev_tools", "system_metrics"])
+            serde_json::json!(["dev_tools", "system_metrics", "github"])
         );
         assert_eq!(config.extra["allowedMcpTools"], serde_json::json!({}));
     }