@pheem49/mint 1.8.2 → 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,
@@ -693,22 +685,27 @@ 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);
+                                        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);
+                                            crate::ACTIVE_AGENTS
+                                                .lock()
+                                                .unwrap()
+                                                .remove(&chat_id_str_cleanup);
                                         }
                                     });
                                 } else {
@@ -768,22 +765,27 @@ 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);
+                                        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);
+                                            crate::ACTIVE_AGENTS
+                                                .lock()
+                                                .unwrap()
+                                                .remove(&chat_id_str_cleanup);
                                         }
                                     });
                                 }
@@ -1135,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());

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)
@@ -230,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 {
@@ -259,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 {
@@ -708,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()
@@ -720,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(()),
     }

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();
         }
     }