@pheem49/mint 1.8.1 → 1.8.2

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

@@ -803,6 +803,7 @@ async fn main() -> Result<()> {
                             audio_data_uri: None,
                             document_attachment: None,
                             workspace_path: None,
+                            agent_id: None,
                         },
                     )
                     .await?;
@@ -1761,8 +1762,12 @@ async fn handle_slash_command(
                 ("/mcp list", "List configured MCP servers"),
                 ("/mcp allow <server> <tool>", "Allow an MCP tool"),
                 ("/stats", "Show session statistics"),
-                ("/exit | /quit", "Exit Mint"),
+                ("/exit", "Exit Mint"),
                 ("/code <task>", "Run in code-agent mode"),
+                (
+                    "/multi-agent [on|off]",
+                    "Show or toggle Multi-Agent Collaboration system",
+                ),
             ];
             for (cmd_name, desc) in &commands {
                 println!("  {MINT}{:<30}{RESET} {DIM}{}{RESET}", cmd_name, desc);
@@ -1803,13 +1808,77 @@ async fn handle_slash_command(
                 println!();
             } else {
                 session.config.ai_provider = rest.to_owned();
+                match mint_core::save_config(&session.config) {
+                    Ok(()) => {
+                        let active_model = active_model(&session.config.ai_provider, &session.config);
+                        let display_name = format!("Changed model to {} • {}", session.config.ai_provider, active_model);
+
+                        // Save system event interaction in memory
+                        if let Ok(memory) = MemoryStore::open_default() {
+                            let _ = memory.add_interaction_for_chat_with_fallback(
+                                CHAT_CLI_ID,
+                                &display_name,
+                                "",
+                                "system",
+                                "provider_change",
+                                None,
+                            );
+                        }
+
+                        println!(
+                            "\n{DIM}───{RESET} {MINT}{}{RESET} {DIM}───{RESET}\n",
+                            display_name
+                        );
+                    }
+                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                }
+            }
+            Some(SlashResult::Handled)
+        }
+
+        "/multi-agent" => {
+            if rest == "on" || rest == "off" {
+                session.config.enable_agent_collaboration = rest == "on";
                 match mint_core::save_config(&session.config) {
                     Ok(()) => println!(
-                        "{DIM}Switched to provider: {}{RESET}\n",
-                        session.config.ai_provider
+                        "{DIM}Multi-Agent collaboration set to: {}{RESET}\n",
+                        if session.config.enable_agent_collaboration { "Enabled" } else { "Disabled" }
                     ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
                 }
+            } else if !rest.is_empty() {
+                println!("{WARN}Usage: /multi-agent [on|off]{RESET}\n");
+            } else {
+                println!("\n{BLUE}Multi-Agent System Settings:{RESET}");
+                let collab_status = if session.config.enable_agent_collaboration {
+                    format!("{MINT}Enabled (on){RESET}")
+                } else {
+                    format!("{DIM}Disabled (off){RESET}")
+                };
+                println!("  Global Collaboration: {collab_status}");
+                println!("\n{BLUE}Configured Agents:{RESET}");
+                if session.config.agents.is_empty() {
+                    println!("  No agents configured.");
+                } else {
+                    for agent in &session.config.agents {
+                        let status_label = if agent.enabled {
+                            format!("{MINT}[Enabled]{RESET}")
+                        } else {
+                            format!("{DIM}[Disabled]{RESET}")
+                        };
+                        println!(
+                            "  {:<15} {}  Provider: {:<12} Model: {}",
+                            agent.name, status_label, agent.provider, agent.model
+                        );
+                        let truncated_instruction = if agent.system_instruction.len() > 60 {
+                            format!("{}...", &agent.system_instruction[..60].replace('\n', " "))
+                        } else {
+                            agent.system_instruction.replace('\n', " ")
+                        };
+                        println!("    {DIM}Instruction: {truncated_instruction}{RESET}");
+                    }
+                }
+                println!();
             }
             Some(SlashResult::Handled)
         }
@@ -2542,6 +2611,7 @@ async fn run_interactive_chat() -> Result<()> {
                     audio_data_uri: None,
                     document_attachment: None,
                     workspace_path: None,
+                    agent_id: None,
                 },
                 |chunk| {
                     if first_chunk {
@@ -2635,51 +2705,69 @@ fn print_exit_message(session: &InteractiveSession) {
 }
 
 const AUTOCOMPLETE_COMMANDS: &[(&str, &str)] = &[
-    ("/help", "Show help menu"),
+    ("/cd", "Change active workspace directory"),
+    ("/clear", "Clear conversation history"),
+    ("/code", "Run in code-agent mode"),
+    ("/exit", "Exit Mint CLI"),
     ("/fast", "Toggle fast mode (hide thinking traces)"),
-    ("/models", "List AI providers or switch active provider"),
+    ("/help", "Show help menu"),
+    ("/image", "Attach image from disk"),
     (
         "/image-provider",
         "List image gen providers or switch default provider",
     ),
-    ("/clear", "Clear conversation history"),
-    ("/cd", "Change active workspace directory"),
-    ("/image", "Attach image from disk"),
-    ("/paste", "Attach image from clipboard"),
     ("/learn", "Import persistent skill/instruction"),
-    ("/plugins", "List or generate plugins/skills"),
-    ("/memory", "Manage long-term memory store"),
     ("/mcp", "List configured MCP servers"),
+    ("/memory", "Manage long-term memory store"),
+    ("/models", "List AI providers or switch active provider"),
+    ("/multi-agent", "Show or toggle Multi-Agent Collaboration system"),
+    ("/paste", "Attach image from clipboard"),
+    ("/plugins", "List or generate plugins/skills"),
     ("/stats", "Show session statistics"),
-    ("/exit", "Exit Mint CLI"),
-    ("/quit", "Exit Mint CLI"),
-    ("/code", "Run in code-agent mode"),
 ];
 
 fn draw_input_box(
-    input: &str,
+    input_chars: &[char],
+    cursor_pos: usize,
     placeholder: &str,
     model: &str,
     path_str: &str,
     tab_base_input: Option<&str>,
     tab_index: Option<usize>,
-) -> usize {
+) -> (usize, usize) {
     let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
     let width = term_width as usize;
     let prefix = "› ";
     let input_width = width.saturating_sub(2);
     let content_max_len = input_width.saturating_sub(prefix.chars().count());
 
-    let display_str = if input.is_empty() {
+    let mut start_idx = 0;
+    if input_chars.len() > content_max_len {
+        if cursor_pos >= content_max_len {
+            start_idx = (cursor_pos + 5).saturating_sub(content_max_len);
+            if start_idx + content_max_len > input_chars.len() {
+                start_idx = input_chars.len() - content_max_len;
+            }
+        }
+    }
+
+    let slice_chars = if input_chars.len() > content_max_len {
+        &input_chars[start_idx..std::cmp::min(start_idx + content_max_len, input_chars.len())]
+    } else {
+        input_chars
+    };
+    let displayed_input: String = slice_chars.iter().collect();
+
+    let display_str = if displayed_input.is_empty() {
         format!("{DIM}{}\x1b[39m", placeholder)
     } else {
-        format_placeholders(input)
+        format_placeholders(&displayed_input)
     };
 
-    let visible_len = if input.is_empty() {
+    let visible_len = if displayed_input.is_empty() {
         placeholder.chars().count()
     } else {
-        string_visual_width(input)
+        string_visual_width(&displayed_input)
     };
 
     let pad_len = content_max_len.saturating_sub(visible_len);
@@ -2707,7 +2795,8 @@ fn draw_input_box(
     );
 
     // Compute and draw suggestions
-    let search_query = tab_base_input.unwrap_or(input);
+    let raw_input: String = input_chars.iter().collect();
+    let search_query = tab_base_input.unwrap_or(&raw_input);
     let mut match_count = 0;
     if search_query.starts_with('/') {
         let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
@@ -2716,11 +2805,18 @@ fn draw_input_box(
             .collect();
 
         if !matches.is_empty() {
-            match_count = matches.len();
-            println!();
-            println!(" {BLUE}Suggestions{RESET}");
+            let total_pages = (matches.len() + 4) / 5;
             let highlight_idx = tab_index.map(|idx| idx % matches.len());
-            for (i, (cmd, desc)) in matches.iter().enumerate() {
+            let selected_idx = highlight_idx.unwrap_or(0);
+            let current_page = selected_idx / 5;
+            let start_idx = current_page * 5;
+            let end_idx = std::cmp::min(start_idx + 5, matches.len());
+            match_count = end_idx - start_idx;
+
+            println!();
+            println!(" {BLUE}Suggestions ({}/{}){RESET}", current_page + 1, total_pages);
+            for i in start_idx..end_idx {
+                let (cmd, desc) = matches[i];
                 if Some(i) == highlight_idx {
                     println!("  {BLUE}▶ {:<16}{RESET} {DIM}- {}{RESET}", cmd, desc);
                 } else {
@@ -2731,11 +2827,29 @@ fn draw_input_box(
     }
 
     let _ = io::stdout().flush();
-    match_count
+    (match_count, start_idx)
 }
 
 fn input_cursor_column(input_chars: &[char], cursor_pos: usize) -> usize {
-    let visual_cursor_pos: usize = input_chars[..cursor_pos]
+    let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
+    let width = term_width as usize;
+    let prefix = "› ";
+    let input_width = width.saturating_sub(2);
+    let content_max_len = input_width.saturating_sub(prefix.chars().count());
+
+    let mut start_idx = 0;
+    if input_chars.len() > content_max_len {
+        if cursor_pos >= content_max_len {
+            start_idx = (cursor_pos + 5).saturating_sub(content_max_len);
+            if start_idx + content_max_len > input_chars.len() {
+                start_idx = input_chars.len() - content_max_len;
+            }
+        }
+    }
+
+    let cursor_pos_clamped = std::cmp::min(cursor_pos, input_chars.len());
+    let start_idx_clamped = std::cmp::min(start_idx, cursor_pos_clamped);
+    let visual_cursor_pos: usize = input_chars[start_idx_clamped..cursor_pos_clamped]
         .iter()
         .copied()
         .map(char_visual_width)
@@ -2766,9 +2880,9 @@ fn redraw_input_box(
     tab_index: Option<usize>,
 ) {
     clear_input_box();
-    let input: String = input_chars.iter().collect();
-    let match_count = draw_input_box(
-        &input,
+    let (match_count, _) = draw_input_box(
+        input_chars,
+        cursor_pos,
         placeholder,
         model,
         path_str,
@@ -2799,7 +2913,7 @@ fn read_line_interactive(
     let mut tab_base_input: Option<String> = None;
     let mut tab_index: Option<usize> = None;
 
-    let match_count = draw_input_box("", placeholder, model, path_str, None, None);
+    let (match_count, _) = draw_input_box(&input_chars, cursor_pos, placeholder, model, path_str, None, None);
     position_input_cursor(&input_chars, cursor_pos, match_count);
     let _ = io::stdout().flush();
 
@@ -2918,12 +3032,7 @@ fn read_line_interactive(
                             }
                         }
                         KeyCode::Char(c) => {
-                            let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
-                            let max_width = (term_width as usize).saturating_sub(4);
-                            let current_visual_width: usize =
-                                input_chars.iter().copied().map(char_visual_width).sum();
-
-                            if current_visual_width < max_width {
+                            if input_chars.len() < 10000 {
                                 input_chars.insert(cursor_pos, c);
                                 cursor_pos += 1;
 
@@ -3092,13 +3201,15 @@ fn read_line_interactive(
                                 }
                             }
                             disable_raw_mode()?;
-                            let visual_cursor_pos: usize = input_chars[..cursor_pos]
-                                .iter()
-                                .copied()
-                                .map(char_visual_width)
-                                .sum();
-                            print!("\x1b[{}G", 4 + visual_cursor_pos);
-                            let _ = io::stdout().flush();
+                            redraw_input_box(
+                                &input_chars,
+                                cursor_pos,
+                                placeholder,
+                                model,
+                                path_str,
+                                None,
+                                None,
+                            );
                             enable_raw_mode()?;
                         }
                         KeyCode::Right => {
@@ -3111,13 +3222,15 @@ fn read_line_interactive(
                                 }
                             }
                             disable_raw_mode()?;
-                            let visual_cursor_pos: usize = input_chars[..cursor_pos]
-                                .iter()
-                                .copied()
-                                .map(char_visual_width)
-                                .sum();
-                            print!("\x1b[{}G", 4 + visual_cursor_pos);
-                            let _ = io::stdout().flush();
+                            redraw_input_box(
+                                &input_chars,
+                                cursor_pos,
+                                placeholder,
+                                model,
+                                path_str,
+                                None,
+                                None,
+                            );
                             enable_raw_mode()?;
                         }
                         KeyCode::Enter => {
@@ -3566,6 +3679,7 @@ async fn run_github_overview(repo: &str, config: &MintConfig) -> Result<()> {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         },
     )
     .await?;

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

@@ -61,6 +61,7 @@ where
                 audio_data_uri: None,
                 document_attachment: None,
                 workspace_path: None,
+                agent_id: None,
             },
         )
         .await?;

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

@@ -476,6 +476,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         image_data_uri: Option<String>,
                         audio_data_uri: Option<String>,
                         document_attachment: Option<crate::chat::DocumentAttachment>,
+                        agent_id: Option<String>,
                     }
 
                     if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
@@ -488,6 +489,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             audio_data_uri: req.audio_data_uri,
                             document_attachment: req.document_attachment,
                             workspace_path: None,
+                            agent_id: req.agent_id,
                         };
                         let mut chat_req =
                             chat_req.with_document_context(&config).unwrap_or(chat_req);
@@ -550,6 +552,24 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
+                ("POST", "/api/cancel-chat") => {
+                    #[derive(Deserialize)]
+                    #[serde(rename_all = "camelCase")]
+                    struct CancelRequest {
+                        chat_id: String,
+                    }
+                    if let Ok(req) = serde_json::from_str::<CancelRequest>(body) {
+                        crate::cancel_agent(&req.chat_id);
+                        send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
+                    } else {
+                        send_json_response(
+                            socket,
+                            "400 Bad Request",
+                            "{\"status\":\"invalid cancel body\"}",
+                        )
+                        .await;
+                    }
+                }
                 ("POST", "/api/chat-stream") => {
                     #[derive(Deserialize)]
                     #[serde(rename_all = "camelCase")]
@@ -560,6 +580,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         image_data_uri: Option<String>,
                         audio_data_uri: Option<String>,
                         document_attachment: Option<crate::chat::DocumentAttachment>,
+                        agent_id: Option<String>,
                     }
 
                     if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
@@ -572,6 +593,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             audio_data_uri: req.audio_data_uri,
                             document_attachment: req.document_attachment,
                             workspace_path: None,
+                            agent_id: req.agent_id,
                         };
                         let mut chat_req =
                             chat_req.with_document_context(&config).unwrap_or(chat_req);
@@ -631,7 +653,8 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                     let config_clone = config.clone();
                                     let chat_req_clone = chat_req.clone();
                                     let tx_done = tx.clone();
-                                    tokio::spawn(async move {
+                                    let chat_id_str = chat_req.chat_id.clone().unwrap_or_default();
+                                    let join_handle = tokio::spawn(async move {
                                         let result = orchestrate_chat_stream_with_fallback(
                                             &config_clone,
                                             &chat_req_clone,
@@ -675,6 +698,19 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                             }
                                         }
                                     });
+
+                                    let abort_handle = join_handle.abort_handle();
+                                    if !chat_id_str.is_empty() {
+                                        crate::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+                                    }
+
+                                    let chat_id_str_cleanup = chat_id_str.clone();
+                                    tokio::spawn(async move {
+                                        let _ = join_handle.await;
+                                        if !chat_id_str_cleanup.is_empty() {
+                                            crate::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str_cleanup);
+                                        }
+                                    });
                                 } else {
                                     let root = std::env::current_dir().unwrap_or_default();
                                     let fast_mode = config
@@ -686,16 +722,19 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                     let tx_done = tx.clone();
                                     let config_clone = config.clone();
                                     let chat_id = chat_req.chat_id.clone();
+                                    let chat_id_str = chat_id.clone().unwrap_or_default();
                                     let message = chat_req.message.clone();
                                     let image_data_uri = chat_req.image_data_uri.clone();
+                                    let agent_id = chat_req.agent_id.clone();
 
-                                    tokio::spawn(async move {
+                                    let join_handle = tokio::spawn(async move {
                                         let result = orchestrate_agent_loop(
                                             &config_clone,
                                             &message,
                                             &root,
                                             image_data_uri,
                                             chat_id.as_deref(),
+                                            agent_id.as_deref(),
                                             fast_mode,
                                             |_| Ok(ApprovalOutcome::Denied),
                                             progress_cb,
@@ -734,6 +773,19 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                             }
                                         }
                                     });
+
+                                    let abort_handle = join_handle.abort_handle();
+                                    if !chat_id_str.is_empty() {
+                                        crate::ACTIVE_AGENTS.lock().unwrap().insert(chat_id_str.clone(), abort_handle);
+                                    }
+
+                                    let chat_id_str_cleanup = chat_id_str.clone();
+                                    tokio::spawn(async move {
+                                        let _ = join_handle.await;
+                                        if !chat_id_str_cleanup.is_empty() {
+                                            crate::ACTIVE_AGENTS.lock().unwrap().remove(&chat_id_str_cleanup);
+                                        }
+                                    });
                                 }
                             }
 
@@ -894,6 +946,7 @@ async fn run_web_agent_loop(
         &root,
         request.image_data_uri.clone(),
         request.chat_id.as_deref(),
+        request.agent_id.as_deref(),
         fast_mode,
         |_| Ok(ApprovalOutcome::Denied),
         |_| {},

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

@@ -340,6 +340,61 @@ async fn cdp_call(config: &MintConfig, method: &str, params: Value) -> Result<Va
     let (mut socket, _) = connect_async(socket_url)
         .await
         .map_err(|error| format!("unable to connect to Chrome DevTools websocket: {error}"))?;
+    let is_aura_script = method == "Runtime.evaluate"
+        && params["expression"]
+            .as_str()
+            .map(|s| s.contains("mint-browser-aura"))
+            .unwrap_or(false);
+
+    if !is_aura_script {
+        let aura_script = r#"
+            (() => {
+                if (document.getElementById('mint-browser-aura')) return;
+                const aura = document.createElement('div');
+                aura.id = 'mint-browser-aura';
+                
+                const style = document.createElement('style');
+                style.id = 'mint-browser-aura-style';
+                style.textContent = `
+                    @keyframes mint-pulse {
+                        0% { box-shadow: inset 0 0 15px rgba(16, 185, 129, 0.4); border-color: rgba(16, 185, 129, 0.6); }
+                        100% { box-shadow: inset 0 0 30px rgba(16, 185, 129, 0.8); border-color: rgba(16, 185, 129, 1); }
+                    }
+                `;
+                document.head.appendChild(style);
+                
+                aura.style.cssText = `
+                    position: fixed;
+                    top: 0;
+                    left: 0;
+                    width: 100vw;
+                    height: 100vh;
+                    border: 5px solid rgba(16, 185, 129, 0.6);
+                    pointer-events: none;
+                    z-index: 2147483647;
+                    box-sizing: border-box;
+                    animation: mint-pulse 1.5s infinite alternate;
+                `;
+                document.body.appendChild(aura);
+            })()
+        "#;
+
+        let _ = socket
+            .send(Message::Text(
+                json!({
+                    "id": 999,
+                    "method": "Runtime.evaluate",
+                    "params": {
+                        "expression": aura_script,
+                        "returnByValue": true
+                    }
+                })
+                .to_string()
+                .into(),
+            ))
+            .await;
+    }
+
     socket
         .send(Message::Text(
             json!({ "id": 1, "method": method, "params": params })

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

@@ -194,6 +194,7 @@ async fn answer(text: &str, system_instruction: &str) -> String {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         },
     )
     .await

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

@@ -99,6 +99,8 @@ pub struct ChatRequest {
     pub document_attachment: Option<DocumentAttachment>,
     #[serde(default)]
     pub workspace_path: Option<String>,
+    #[serde(default)]
+    pub agent_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -965,6 +967,7 @@ mod tests {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         })
         .unwrap();
         assert_eq!(parts.len(), 3);

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

@@ -79,10 +79,24 @@ pub struct MintConfig {
     pub blocked_paths: Vec<PathBuf>,
     pub blocked_file_names: Vec<String>,
     pub disabled_tools: Vec<String>,
+    pub agents: Vec<AgentConfig>,
+    pub enable_agent_collaboration: bool,
     #[serde(flatten)]
     pub extra: BTreeMap<String, Value>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentConfig {
+    pub id: String,
+    pub name: String,
+    pub provider: String,
+    pub model: String,
+    pub api_key: Option<String>,
+    pub system_instruction: String,
+    pub enabled: bool,
+}
+
 impl Default for MintConfig {
     fn default() -> Self {
         let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -142,12 +156,59 @@ impl Default for MintConfig {
             ],
             blocked_file_names: vec![".env".into(), "id_rsa".into(), "id_ed25519".into()],
             disabled_tools: Vec::new(),
+            agents: default_agents(),
+            enable_agent_collaboration: false,
             extra: runtime_extra_defaults(),
         }
     }
 }
 
+fn default_agents() -> Vec<AgentConfig> {
+    vec![
+        AgentConfig {
+            id: "planner".into(),
+            name: "Planner".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Planner agent. Your task is to analyze the user request, inspect the workspace structure, and design a step-by-step implementation plan. Create or update the implementation_plan.md file to document your proposal.".into(),
+            enabled: true,
+        },
+        AgentConfig {
+            id: "coder".into(),
+            name: "Coder".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Coder agent. Your task is to implement the changes specified in the approved implementation plan. Read relevant files, write clean and efficient code, and run terminal commands to build or verify. Stay focused on execution.".into(),
+            enabled: true,
+        },
+        AgentConfig {
+            id: "reviewer".into(),
+            name: "Reviewer".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Reviewer agent. Your task is to verify the code modifications made by the Coder. Run the automated tests, check lint errors, and ensure the implementation is correct and complete.".into(),
+            enabled: true,
+        },
+    ]
+}
+
 impl MintConfig {
+    pub fn active_model(&self) -> &str {
+        match self.ai_provider.as_str() {
+            "anthropic" => &self.anthropic_model,
+            "openai" => &self.openai_model,
+            "openrouter" => &self.openrouter_model,
+            "deepseek" => &self.deepseek_model,
+            "huggingface" => &self.hf_model,
+            "local_openai" => &self.local_model_name,
+            "ollama" => &self.ollama_model,
+            _ => &self.gemini_model,
+        }
+    }
+
     pub fn available_providers(&self) -> Vec<&'static str> {
         let mut providers = Vec::new();
         if has_value(&self.anthropic_api_key) {