@pheem49/mint 1.8.1 → 1.9.0

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

@@ -213,16 +213,15 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         new_title: String,
                     }
 
-                    if let Ok(req) = serde_json::from_str::<RenameRequest>(body) {
-                        if let Ok(memory) = MemoryStore::open_default() {
-                            let updated = memory
-                                .rename_chat_session(&req.chat_id, &req.new_title)
-                                .unwrap_or(0);
-                            let response =
-                                serde_json::json!({ "status": "ok", "updated": updated });
-                            send_json_response(socket, "200 OK", &response.to_string()).await;
-                            return;
-                        }
+                    if let Ok(req) = serde_json::from_str::<RenameRequest>(body)
+                        && let Ok(memory) = MemoryStore::open_default()
+                    {
+                        let updated = memory
+                            .rename_chat_session(&req.chat_id, &req.new_title)
+                            .unwrap_or(0);
+                        let response = serde_json::json!({ "status": "ok", "updated": updated });
+                        send_json_response(socket, "200 OK", &response.to_string()).await;
+                        return;
                     }
                     send_json_response(
                         socket,
@@ -252,12 +251,12 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         key: String,
                         value: String,
                     }
-                    if let Ok(req) = serde_json::from_str::<ProfileRequest>(body) {
-                        if let Ok(memory) = MemoryStore::open_default() {
-                            let _ = memory.set_profile(&req.key, &req.value);
-                            send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
-                            return;
-                        }
+                    if let Ok(req) = serde_json::from_str::<ProfileRequest>(body)
+                        && let Ok(memory) = MemoryStore::open_default()
+                    {
+                        let _ = memory.set_profile(&req.key, &req.value);
+                        send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
+                        return;
                     }
                     send_json_response(
                         socket,
@@ -341,25 +340,18 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         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(_) => {}
-                            }
-                        }
+                    if let Ok(payload) = serde_json::from_str::<SaveAgentActivityRequest>(body)
+                        && let Ok(memory) = MemoryStore::open_default()
+                        && let Ok(activity_json) = serde_json::to_string(&payload.activity)
+                        && memory
+                            .set_interaction_agent_activity_json(
+                                payload.interaction_id,
+                                &activity_json,
+                            )
+                            .is_ok()
+                    {
+                        send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
+                        return;
                     }
                     send_json_response(
                         socket,
@@ -406,11 +398,11 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     }
                 }
                 ("POST", "/api/config") => {
-                    if let Ok(new_config) = serde_json::from_str::<MintConfig>(body) {
-                        if save_config(&new_config).is_ok() {
-                            send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
-                            return;
-                        }
+                    if let Ok(new_config) = serde_json::from_str::<MintConfig>(body)
+                        && save_config(&new_config).is_ok()
+                    {
+                        send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
+                        return;
                     }
                     send_json_response(
                         socket,
@@ -476,6 +468,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 +481,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 +544,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 +572,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 +585,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 +645,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,
@@ -670,11 +685,29 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                                         "text": format!("Error orchestrating chat: {e}")
                                                     }
                                                 });
-                                                let _ = tx_done
-                                                    .send(format!("{}\n", err_json.to_string()));
+                                                let _ = tx_done.send(format!("{}\n", err_json));
                                             }
                                         }
                                     });
+
+                                    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 +719,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,
@@ -729,11 +765,29 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                                         "text": format!("Error orchestrating agent: {e}")
                                                     }
                                                 });
-                                                let _ = tx_done
-                                                    .send(format!("{}\n", err_json.to_string()));
+                                                let _ = tx_done.send(format!("{}\n", err_json));
                                             }
                                         }
                                     });
+
+                                    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 +948,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),
         |_| {},
@@ -1082,12 +1137,13 @@ fn percent_decode(raw: &str) -> String {
     let mut output = Vec::with_capacity(bytes.len());
     let mut index = 0;
     while index < bytes.len() {
-        if bytes[index] == b'%' && index + 2 < bytes.len() {
-            if let Ok(hex) = u8::from_str_radix(&raw[index + 1..index + 3], 16) {
-                output.push(hex);
-                index += 3;
-                continue;
-            }
+        if bytes[index] == b'%'
+            && index + 2 < bytes.len()
+            && let Ok(hex) = u8::from_str_radix(&raw[index + 1..index + 3], 16)
+        {
+            output.push(hex);
+            index += 3;
+            continue;
         }
         output.push(if bytes[index] == b'+' {
             b' '

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

@@ -243,7 +243,7 @@ pub async fn spawn_automation_browser(config: &MintConfig) -> Result<(), String>
         .unwrap_or("chromium");
 
     let profile_dir = dirs::config_dir()
-        .unwrap_or_else(|| std::env::temp_dir())
+        .unwrap_or_else(std::env::temp_dir)
         .join("mint")
         .join("automation-profile");
     let profile_arg = format!("--user-data-dir={}", profile_dir.to_string_lossy());
@@ -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

@@ -19,13 +19,13 @@ pub async fn send_chat_with_fallback(
         Err(_) => {}
     }
     for provider in config.available_providers() {
-        if provider == config.ai_provider.as_str() {
+        if provider.as_str() == config.ai_provider.as_str() {
             continue;
         }
-        let alt = config_for_provider(config, provider);
+        let alt = config_for_provider(config, &provider);
         if let Ok(mut r) = send_chat(&alt, request).await {
             r.fallback_provider = Some(config.ai_provider.clone());
-            return Ok((r, Some(provider.to_owned())));
+            return Ok((r, Some(provider)));
         }
     }
     // all fallbacks failed — retry primary to surface original error
@@ -50,13 +50,13 @@ where
         }
     }
     for provider in config.available_providers() {
-        if provider == config.ai_provider.as_str() {
+        if provider.as_str() == config.ai_provider.as_str() {
             continue;
         }
-        let alt = config_for_provider(config, provider);
+        let alt = config_for_provider(config, &provider);
         if let Ok(mut r) = stream_chat(&alt, request, &mut on_chunk).await {
             r.fallback_provider = Some(config.ai_provider.clone());
-            return Ok((r, Some(provider.to_owned())));
+            return Ok((r, Some(provider)));
         }
     }
     stream_chat(config, request, &mut on_chunk)
@@ -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)]
@@ -228,6 +230,7 @@ pub async fn send_chat(
         "ollama" => call_ollama(&client, config, request).await?,
         "anthropic" => call_anthropic(&client, config, request).await?,
         "huggingface" => call_huggingface(&client, config, request).await?,
+        p if p.starts_with("custom:") => call_custom_provider(&client, config, request).await?,
         other => return Err(ChatError::UnsupportedProvider(other.into())),
     };
     Ok(ChatResponse {
@@ -257,6 +260,9 @@ where
         "ollama" => stream_ollama(&client, config, request, &mut on_chunk).await?,
         "anthropic" => stream_anthropic(&client, config, request, &mut on_chunk).await?,
         "huggingface" => stream_huggingface(&client, config, request, &mut on_chunk).await?,
+        p if p.starts_with("custom:") => {
+            stream_custom_provider(&client, config, request, &mut on_chunk).await?
+        }
         other => return Err(ChatError::UnsupportedProvider(other.into())),
     };
     Ok(ChatResponse {
@@ -706,6 +712,109 @@ fn required_key(provider: &str, key: &str) -> Result<(), ChatError> {
     }
 }
 
+/// Resolve which model to use for the current custom provider.
+///
+/// Checks `config.extra["customModelSelections"]` first (set by the UI when the
+/// user picks a specific model from the multi-model dropdown), then falls back to
+/// the first model defined in the `CustomProvider`.
+fn resolve_custom_model(config: &crate::MintConfig) -> String {
+    let provider_id = config
+        .ai_provider
+        .strip_prefix("custom:")
+        .unwrap_or(&config.ai_provider);
+
+    // Check if a per-provider model selection was persisted in extra config.
+    if let Some(selections) = config
+        .extra
+        .get("customModelSelections")
+        .and_then(|v| v.as_object())
+        && let Some(model) = selections.get(provider_id).and_then(|v| v.as_str())
+        && !model.is_empty()
+    {
+        return model.to_owned();
+    }
+
+    // Fall back to the first model in the provider definition.
+    config
+        .resolve_custom_provider(&config.ai_provider)
+        .and_then(|cp| cp.models.first())
+        .map(|m| m.model_id.clone())
+        .unwrap_or_default()
+}
+
+async fn call_custom_provider(
+    client: &Client,
+    config: &crate::MintConfig,
+    request: &ChatRequest,
+) -> Result<(String, String), ChatError> {
+    let provider = config
+        .resolve_custom_provider(&config.ai_provider)
+        .ok_or_else(|| ChatError::UnsupportedProvider(config.ai_provider.clone()))?;
+
+    let base_url = provider.base_url.trim_end_matches('/');
+    let model = resolve_custom_model(config);
+    let payload = openai_chat_payload(&model, request, false);
+
+    let mut builder = client
+        .post(format!("{base_url}/chat/completions"))
+        .json(&payload);
+
+    if !provider.api_key.is_empty() {
+        builder = builder.bearer_auth(&provider.api_key);
+    }
+    for h in &provider.headers {
+        if !h.name.is_empty() {
+            builder = builder.header(h.name.as_str(), h.value.as_str());
+        }
+    }
+
+    let response: serde_json::Value = builder.send().await?.error_for_status()?.json().await?;
+
+    Ok((
+        model,
+        response["choices"][0]["message"]["content"]
+            .as_str()
+            .ok_or(ChatError::MissingResponseText)?
+            .into(),
+    ))
+}
+
+async fn stream_custom_provider<F>(
+    client: &Client,
+    config: &crate::MintConfig,
+    request: &ChatRequest,
+    on_chunk: &mut F,
+) -> Result<(String, String), ChatError>
+where
+    F: FnMut(String),
+{
+    let provider = config
+        .resolve_custom_provider(&config.ai_provider)
+        .ok_or_else(|| ChatError::UnsupportedProvider(config.ai_provider.clone()))?;
+
+    let base_url = provider.base_url.trim_end_matches('/');
+    let model = resolve_custom_model(config);
+    let payload = openai_chat_payload(&model, request, true);
+
+    let mut builder = client
+        .post(format!("{base_url}/chat/completions"))
+        .json(&payload);
+
+    if !provider.api_key.is_empty() {
+        builder = builder.bearer_auth(&provider.api_key);
+    }
+    for h in &provider.headers {
+        if !h.name.is_empty() {
+            builder = builder.header(h.name.as_str(), h.value.as_str());
+        }
+    }
+
+    let response = builder.send().await?.error_for_status()?;
+    collect_stream(response, StreamFormat::OpenAi, on_chunk)
+        .await
+        .map(|text| (model, text))
+}
+
 fn provider_key(configured: &str, environment_variable: &str) -> String {
     if configured.trim().is_empty() {
         std::env::var(environment_variable).unwrap_or_default()
@@ -718,16 +827,24 @@ fn require_supported_attachments(provider: &str, request: &ChatRequest) -> Resul
     let has_image = request
         .image_data_uri
         .as_ref()
-        .map_or(false, |s| !s.trim().is_empty());
+        .is_some_and(|s| !s.trim().is_empty());
     let has_audio = request
         .audio_data_uri
         .as_ref()
-        .map_or(false, |s| !s.trim().is_empty());
+        .is_some_and(|s| !s.trim().is_empty());
 
     match provider {
         "gemini" => Ok(()),
         "ollama" if has_audio => Err(ChatError::UnsupportedAttachments(provider.into())),
         "ollama" => Ok(()),
+        // Custom providers are text-only for now; reject any multimodal content.
+        p if p.starts_with("custom:") => {
+            if has_image || has_audio {
+                Err(ChatError::UnsupportedAttachments(provider.into()))
+            } else {
+                Ok(())
+            }
+        }
         _ if has_image || has_audio => Err(ChatError::UnsupportedAttachments(provider.into())),
         _ => Ok(()),
     }
@@ -965,6 +1082,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/code_tools.rs

@@ -536,18 +536,17 @@ pub async fn fetch_github_repo_summary(owner: &str, repo: &str) -> Result<String
         .await
         .map_err(|e| e.to_string())?;
     let mut file_tree = String::from("Unavailable");
-    if contents_resp.status().is_success() {
-        if let Ok(contents_info) = contents_resp.json::<serde_json::Value>().await {
-            if let Some(arr) = contents_info.as_array() {
-                let mut files = Vec::new();
-                for item in arr {
-                    let name = item["name"].as_str().unwrap_or("");
-                    let r#type = item["type"].as_str().unwrap_or("");
-                    files.push(format!("- {} ({})", name, r#type));
-                }
-                file_tree = files.join("\n");
-            }
+    if contents_resp.status().is_success()
+        && let Ok(contents_info) = contents_resp.json::<serde_json::Value>().await
+        && let Some(arr) = contents_info.as_array()
+    {
+        let mut files = Vec::new();
+        for item in arr {
+            let name = item["name"].as_str().unwrap_or("");
+            let r#type = item["type"].as_str().unwrap_or("");
+            files.push(format!("- {} ({})", name, r#type));
         }
+        file_tree = files.join("\n");
     }
 
     // 3. Fetch README.md
@@ -558,15 +557,14 @@ pub async fn fetch_github_repo_summary(owner: &str, repo: &str) -> Result<String
         .await
         .map_err(|e| e.to_string())?;
     let mut readme_text = String::from("No README available.");
-    if readme_resp.status().is_success() {
-        if let Ok(readme_info) = readme_resp.json::<serde_json::Value>().await {
-            if let Some(content_b64) = readme_info["content"].as_str() {
-                let cleaned_b64 = content_b64.replace('\n', "").replace('\r', "");
-                use base64::{Engine as _, engine::general_purpose::STANDARD};
-                if let Ok(decoded_bytes) = STANDARD.decode(cleaned_b64) {
-                    readme_text = String::from_utf8_lossy(&decoded_bytes).to_string();
-                }
-            }
+    if readme_resp.status().is_success()
+        && let Ok(readme_info) = readme_resp.json::<serde_json::Value>().await
+        && let Some(content_b64) = readme_info["content"].as_str()
+    {
+        let cleaned_b64 = content_b64.replace(['\n', '\r'], "");
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        if let Ok(decoded_bytes) = STANDARD.decode(cleaned_b64) {
+            readme_text = String::from_utf8_lossy(&decoded_bytes).to_string();
         }
     }