@pheem49/mint 1.8.1 → 1.9.0

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

@@ -79,10 +79,65 @@ 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,
+    /// User-defined OpenAI-compatible providers.
+    pub custom_providers: Vec<CustomProvider>,
     #[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,
+}
+
+/// A single model entry inside a [`CustomProvider`].
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomProviderModel {
+    /// The model identifier sent to the API, e.g. `"llama-3.1-8b"`.
+    pub model_id: String,
+    /// Human-readable label shown in the UI, e.g. `"Llama 3.1 8B"`.
+    pub display_name: String,
+}
+
+/// An extra HTTP header to include with every request to a [`CustomProvider`].
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomProviderHeader {
+    pub name: String,
+    pub value: String,
+}
+
+/// A fully user-defined, OpenAI-compatible AI provider.
+///
+/// When this provider is active the `ai_provider` config field is set to
+/// `"custom:<id>"` where `<id>` is [`CustomProvider::id`].
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomProvider {
+    /// Slug identifier (lowercase letters, numbers, hyphens, underscores).
+    pub id: String,
+    /// Human-readable name shown in the UI.
+    pub display_name: String,
+    /// Base URL of the OpenAI-compatible endpoint, e.g. `"http://localhost:20128/v1"`.
+    pub base_url: String,
+    /// API key sent as `Authorization: Bearer <key>`. Empty = no auth header.
+    pub api_key: String,
+    /// Models offered by this provider.
+    pub models: Vec<CustomProviderModel>,
+    /// Optional extra HTTP headers sent with every request.
+    pub headers: Vec<CustomProviderHeader>,
+}
+
 impl Default for MintConfig {
     fn default() -> Self {
         let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -142,36 +197,106 @@ 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,
+            custom_providers: Vec::new(),
             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 available_providers(&self) -> Vec<&'static str> {
+    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,
+            p if p.starts_with("custom:") => {
+                // Return the first model id of the matching custom provider, if any.
+                self.resolve_custom_provider(p)
+                    .and_then(|cp| cp.models.first())
+                    .map(|m| m.model_id.as_str())
+                    .unwrap_or("")
+            }
+            _ => &self.gemini_model,
+        }
+    }
+
+    /// Returns the `CustomProvider` whose id matches `provider_key`.
+    ///
+    /// `provider_key` must be in `"custom:<id>"` format (the leading `"custom:"`
+    /// prefix is stripped before the lookup).
+    pub fn resolve_custom_provider(&self, provider_key: &str) -> Option<&CustomProvider> {
+        let id = provider_key.strip_prefix("custom:").unwrap_or(provider_key);
+        self.custom_providers.iter().find(|cp| cp.id == id)
+    }
+
+    pub fn available_providers(&self) -> Vec<String> {
         let mut providers = Vec::new();
         if has_value(&self.anthropic_api_key) {
-            providers.push("anthropic");
+            providers.push("anthropic".to_owned());
         }
         if has_value(&self.openai_api_key) {
-            providers.push("openai");
+            providers.push("openai".to_owned());
         }
         if has_value(&self.openrouter_api_key) {
-            providers.push("openrouter");
+            providers.push("openrouter".to_owned());
         }
         if has_value(&self.deepseek_api_key) {
-            providers.push("deepseek");
+            providers.push("deepseek".to_owned());
         }
         if has_value(&self.api_key) {
-            providers.push("gemini");
+            providers.push("gemini".to_owned());
         }
         if has_value(&self.hf_api_key) {
-            providers.push("huggingface");
+            providers.push("huggingface".to_owned());
         }
         if has_value(&self.local_api_base_url) {
-            providers.push("local_openai");
+            providers.push("local_openai".to_owned());
+        }
+        providers.push("ollama".to_owned());
+        // Include all user-defined custom providers that have a base URL configured.
+        for cp in &self.custom_providers {
+            if !cp.base_url.trim().is_empty() {
+                providers.push(format!("custom:{}", cp.id));
+            }
         }
-        providers.push("ollama");
         providers
     }
 }
@@ -377,7 +502,10 @@ mod tests {
 
     #[test]
     fn default_config_always_exposes_ollama() {
-        assert_eq!(MintConfig::default().available_providers(), vec!["ollama"]);
+        assert_eq!(
+            MintConfig::default().available_providers(),
+            vec!["ollama".to_owned()]
+        );
     }
 
     #[test]
@@ -393,12 +521,12 @@ mod tests {
         assert_eq!(
             config.available_providers(),
             vec![
-                "openai",
-                "openrouter",
-                "deepseek",
-                "gemini",
-                "local_openai",
-                "ollama"
+                "openai".to_owned(),
+                "openrouter".to_owned(),
+                "deepseek".to_owned(),
+                "gemini".to_owned(),
+                "local_openai".to_owned(),
+                "ollama".to_owned(),
             ]
         );
     }
@@ -448,8 +576,108 @@ mod tests {
         save_config_to(&path, &initial_config).unwrap();
 
         let loaded = load_config_from(&path).unwrap();
-        assert!(loaded.theme.len() > 0);
+        assert!(!loaded.theme.is_empty());
 
         let _ = std::fs::remove_file(&path);
     }
+
+    #[test]
+    fn custom_provider_round_trips() {
+        let config = MintConfig {
+            custom_providers: vec![CustomProvider {
+                id: "myprovider".into(),
+                display_name: "My Provider".into(),
+                base_url: "http://localhost:20128/v1".into(),
+                api_key: "sk-abc".into(),
+                models: vec![CustomProviderModel {
+                    model_id: "llama-3.1-8b".into(),
+                    display_name: "Llama 3.1 8B".into(),
+                }],
+                headers: vec![CustomProviderHeader {
+                    name: "X-Custom".into(),
+                    value: "test".into(),
+                }],
+            }],
+            ..MintConfig::default()
+        };
+        let json = serde_json::to_string(&config).unwrap();
+        let restored: MintConfig = serde_json::from_str(&json).unwrap();
+        assert_eq!(restored, config);
+    }
+
+    #[test]
+    fn custom_provider_appears_in_available_providers() {
+        let config = MintConfig {
+            custom_providers: vec![CustomProvider {
+                id: "myprovider".into(),
+                base_url: "http://localhost:20128/v1".into(),
+                ..CustomProvider::default()
+            }],
+            ..MintConfig::default()
+        };
+        assert!(
+            config
+                .available_providers()
+                .contains(&"custom:myprovider".to_owned())
+        );
+    }
+
+    #[test]
+    fn custom_provider_without_base_url_excluded() {
+        let config = MintConfig {
+            custom_providers: vec![CustomProvider {
+                id: "empty".into(),
+                base_url: "".into(),
+                ..CustomProvider::default()
+            }],
+            ..MintConfig::default()
+        };
+        assert!(
+            !config
+                .available_providers()
+                .contains(&"custom:empty".to_owned())
+        );
+    }
+
+    #[test]
+    fn active_model_resolves_first_custom_model() {
+        let config = MintConfig {
+            ai_provider: "custom:myprovider".into(),
+            custom_providers: vec![CustomProvider {
+                id: "myprovider".into(),
+                base_url: "http://localhost:20128/v1".into(),
+                models: vec![CustomProviderModel {
+                    model_id: "llama-3.1-8b".into(),
+                    display_name: String::new(),
+                }],
+                ..CustomProvider::default()
+            }],
+            ..MintConfig::default()
+        };
+        assert_eq!(config.active_model(), "llama-3.1-8b");
+    }
+
+    #[test]
+    fn resolve_custom_provider_returns_none_for_unknown() {
+        let config = MintConfig::default();
+        assert!(
+            config
+                .resolve_custom_provider("custom:nonexistent")
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn resolve_custom_provider_strips_prefix() {
+        let config = MintConfig {
+            custom_providers: vec![CustomProvider {
+                id: "myp".into(),
+                ..CustomProvider::default()
+            }],
+            ..MintConfig::default()
+        };
+        assert!(config.resolve_custom_provider("custom:myp").is_some());
+        // Also works without prefix
+        assert!(config.resolve_custom_provider("myp").is_some());
+    }
 }

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

@@ -659,11 +659,11 @@ async fn call_replicate(
         poll_replicate(client, &api_key, &prediction_url).await?
     };
 
-    if let Some(err) = prediction.get("error") {
-        if !err.is_null() {
-            let msg = err.as_str().unwrap_or("unknown Replicate error");
-            return Err(ImageGenError::ModelError(msg.to_owned()));
-        }
+    if let Some(err) = prediction.get("error")
+        && !err.is_null()
+    {
+        let msg = err.as_str().unwrap_or("unknown Replicate error");
+        return Err(ImageGenError::ModelError(msg.to_owned()));
     }
 
     // Output is an array of image URLs

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

@@ -41,8 +41,8 @@ pub use code_tools::{
     propose_code_edits, read_code_file, repository_summary, search_code,
 };
 pub use config::{
-    ConfigError, MintConfig, config_path, initialize_config, load_config, save_config,
-    set_config_value,
+    AgentConfig, ConfigError, CustomProvider, CustomProviderHeader, CustomProviderModel,
+    MintConfig, config_path, initialize_config, load_config, save_config, set_config_value,
 };
 pub use files::{FileOperationError, PathKind, PathMatch, create_folder, find_paths};
 pub use image_gen::{
@@ -91,3 +91,17 @@ pub use channels::start_channels;
 
 pub static HTTP_CLIENT: std::sync::LazyLock<reqwest::Client> =
     std::sync::LazyLock::new(reqwest::Client::new);
+
+pub static ACTIVE_AGENTS: std::sync::LazyLock<
+    std::sync::Mutex<std::collections::HashMap<String, tokio::task::AbortHandle>>,
+> = std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashMap::new()));
+
+pub fn cancel_agent(chat_id: &str) -> bool {
+    let mut agents = ACTIVE_AGENTS.lock().unwrap();
+    if let Some(handle) = agents.remove(chat_id) {
+        handle.abort();
+        true
+    } else {
+        false
+    }
+}

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

@@ -58,6 +58,8 @@ pub struct LearnedSkill {
     pub source_path: String,
     pub content: String,
     pub created_at: String,
+    #[serde(default)]
+    pub description: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
@@ -624,12 +626,15 @@ fn ensure_column(
 }
 
 fn learned_skill_row(row: &rusqlite::Row<'_>) -> Result<LearnedSkill, rusqlite::Error> {
+    let content: String = row.get(3)?;
+    let description = crate::skills::parse_skill_description(&content);
     Ok(LearnedSkill {
         id: row.get(0)?,
         name: row.get(1)?,
         source_path: row.get(2)?,
-        content: row.get(3)?,
+        content,
         created_at: row.get(4)?,
+        description,
     })
 }