@pheem49/mint 1.9.0 → 1.10.0

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

@@ -61,7 +61,24 @@ async fn telegram_loop() -> Result<(), String> {
             ) else {
                 continue;
             };
-            let answer = answer(text, "Reply concisely for a Telegram chat.").await;
+            let formatted_chat_id = format!("telegram:{chat_id}");
+            if let Ok(config) = load_config() {
+                if config.bridge_ack_enabled() {
+                    let _ = client
+                        .post(format!(
+                            "https://api.telegram.org/bot{token}/sendChatAction"
+                        ))
+                        .json(&json!({ "chat_id": chat_id, "action": "typing" }))
+                        .send()
+                        .await;
+                }
+            }
+            let answer = answer_channel(
+                text,
+                "Reply concisely for a Telegram chat.",
+                Some(formatted_chat_id),
+            )
+            .await;
             let _ = client
                 .post(format!("https://api.telegram.org/bot{token}/sendMessage"))
                 .json(&json!({ "chat_id": chat_id, "text": answer }))
@@ -116,7 +133,14 @@ async fn discord_loop() -> Result<(), String> {
                         mentions.iter().any(|mention| mention["id"].as_str() == Some(&bot_id))
                     });
                     if !direct_message && !mentioned { continue }
-                    let reply = answer(text, "Reply concisely for a Discord chat.").await;
+                    if let Ok(config) = load_config() {
+                        if config.bridge_ack_enabled() {
+                            let _ = crate::HTTP_CLIENT.clone().post(format!("https://discord.com/api/v10/channels/{channel}/typing"))
+                                .header("Authorization", format!("Bot {token}")).send().await;
+                        }
+                    }
+                    let formatted_chat_id = format!("discord:{channel}");
+                    let reply = answer_channel(text, "Reply concisely for a Discord chat.", Some(formatted_chat_id)).await;
                     let _ = crate::HTTP_CLIENT.clone().post(format!("https://discord.com/api/v10/channels/{channel}/messages"))
                         .header("Authorization", format!("Bot {token}")).json(&json!({ "content": reply })).send().await;
                 }
@@ -168,7 +192,13 @@ async fn slack_loop() -> Result<(), String> {
         else {
             continue;
         };
-        let reply = answer(text, "Reply concisely for a Slack chat.").await;
+        let formatted_chat_id = format!("slack:{channel}");
+        let reply = answer_channel(
+            text,
+            "Reply concisely for a Slack chat.",
+            Some(formatted_chat_id),
+        )
+        .await;
         let _ = crate::HTTP_CLIENT
             .clone()
             .post("https://slack.com/api/chat.postMessage")
@@ -180,20 +210,89 @@ async fn slack_loop() -> Result<(), String> {
     Ok(())
 }
 
-async fn answer(text: &str, system_instruction: &str) -> String {
+pub fn is_action_intent(text: &str) -> bool {
+    let lower = text.to_lowercase();
+    let action_keywords = [
+        "แก้",
+        "สร้าง",
+        "ลบ",
+        "รัน",
+        "ตรวจ",
+        "ค้นหา",
+        "เช็ค",
+        "ดูไฟล์",
+        "อ่านไฟล์",
+        "วิเคราะห์ไฟล์",
+        "fix",
+        "create",
+        "build",
+        "run",
+        "delete",
+        "edit",
+        "update",
+        "check",
+        "find",
+        "search",
+        "read file",
+        "git",
+        "patch",
+        "test",
+        "analyze file",
+    ];
+    action_keywords
+        .iter()
+        .any(|&keyword| lower.contains(keyword))
+}
+
+pub async fn answer_channel(
+    text: &str,
+    system_instruction: &str,
+    chat_id: Option<String>,
+) -> String {
     let Ok(config) = load_config() else {
         return "Mint config error".into();
     };
+    let workspace = config.active_workspace_path();
+    let workspace_str = workspace.as_ref().map(|p| p.to_string_lossy().to_string());
+
+    if is_action_intent(text)
+        && let Some(ref root_path) = workspace
+    {
+        if root_path.exists() {
+            let agent_result = crate::orchestrate_agent_loop(
+                &config,
+                text,
+                root_path,
+                None,
+                None,
+                chat_id.as_deref(),
+                None,
+                true,
+                |_approval| Ok(crate::ApprovalOutcome::Approved),
+                |_progress| {},
+                |_chunk| {},
+            )
+            .await;
+
+            if let Ok(res) = agent_result {
+                if !res.summary.trim().is_empty() {
+                    return res.summary;
+                }
+            }
+        }
+    }
+
     orchestrate_chat(
         &config,
         &ChatRequest {
             message: text.into(),
             system_instruction: system_instruction.into(),
-            chat_id: None,
+            chat_id,
             image_data_uri: None,
             audio_data_uri: None,
+            video_data_uri: None,
             document_attachment: None,
-            workspace_path: None,
+            workspace_path: workspace_str,
             agent_id: None,
         },
     )

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

@@ -96,6 +96,8 @@ pub struct ChatRequest {
     #[serde(default)]
     pub audio_data_uri: Option<String>,
     #[serde(default)]
+    pub video_data_uri: Option<String>,
+    #[serde(default)]
     pub document_attachment: Option<DocumentAttachment>,
     #[serde(default)]
     pub workspace_path: Option<String>,
@@ -284,10 +286,12 @@ async fn call_gemini(
     let url =
         format!("https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent");
 
+    let payload = gemini_chat_payload(config, request)?;
+
     let response: Value = client
         .post(url)
         .header("x-goog-api-key", api_key)
-        .json(&gemini_chat_payload(config, request)?)
+        .json(&payload)
         .send()
         .await?
         .error_for_status()?
@@ -832,20 +836,28 @@ fn require_supported_attachments(provider: &str, request: &ChatRequest) -> Resul
         .audio_data_uri
         .as_ref()
         .is_some_and(|s| !s.trim().is_empty());
+    let has_video = request
+        .video_data_uri
+        .as_ref()
+        .is_some_and(|s| !s.trim().is_empty());
 
     match provider {
         "gemini" => Ok(()),
-        "ollama" if has_audio => Err(ChatError::UnsupportedAttachments(provider.into())),
+        "ollama" if has_audio || has_video => {
+            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 {
+            if has_image || has_audio || has_video {
                 Err(ChatError::UnsupportedAttachments(provider.into()))
             } else {
                 Ok(())
             }
         }
-        _ if has_image || has_audio => Err(ChatError::UnsupportedAttachments(provider.into())),
+        _ if has_image || has_audio || has_video => {
+            Err(ChatError::UnsupportedAttachments(provider.into()))
+        }
         _ => Ok(()),
     }
 }
@@ -1035,6 +1047,21 @@ fn gemini_parts(request: &ChatRequest) -> Result<Vec<Value>, ChatError> {
             }));
         }
     }
+    if let Some(ref video_data) = request.video_data_uri {
+        for vid in video_data.split_whitespace() {
+            let payload = vid
+                .strip_prefix("data:")
+                .and_then(|payload| payload.split_once(";base64,"))
+                .filter(|(mime_type, data)| mime_type.starts_with("video/") && !data.is_empty())
+                .ok_or(ChatError::InvalidAttachment)?;
+            parts.push(json!({
+                "inlineData": {
+                    "mimeType": payload.0,
+                    "data": payload.1
+                }
+            }));
+        }
+    }
     Ok(parts)
 }
 
@@ -1048,6 +1075,26 @@ mod tests {
         assert!(matches!(error, ChatError::MissingApiKey(provider) if provider == "gemini"));
     }
 
+    #[test]
+    fn rejects_video_attachments_for_non_gemini_providers() {
+        let request = ChatRequest {
+            message: "describe this video".into(),
+            system_instruction: String::new(),
+            chat_id: None,
+            image_data_uri: None,
+            audio_data_uri: None,
+            video_data_uri: Some("data:video/mp4;base64,AAAA".into()),
+            document_attachment: None,
+            workspace_path: None,
+            agent_id: None,
+        };
+
+        let error = require_supported_attachments("openai", &request).unwrap_err();
+        assert!(
+            matches!(error, ChatError::UnsupportedAttachments(provider) if provider == "openai")
+        );
+    }
+
     #[test]
     fn parses_stream_provider_formats() {
         assert_eq!(
@@ -1080,6 +1127,7 @@ mod tests {
             chat_id: None,
             image_data_uri: Some("data:image/png;base64,aGk= data:image/jpeg;base64,Ynl5".into()),
             audio_data_uri: None,
+            video_data_uri: None,
             document_attachment: None,
             workspace_path: None,
             agent_id: None,

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

@@ -6,6 +6,7 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
+use similar::{ChangeTag, TextDiff};
 use thiserror::Error;
 
 use crate::{Capability, MintConfig, SafetyError, assert_path_capability};
@@ -401,17 +402,34 @@ fn sha256(content: &str) -> String {
 
 fn full_file_diff(path: &Path, previous: &str, next: &str) -> String {
     let label = path.display();
-    let mut lines = vec![
-        format!("--- a/{label}"),
-        format!("+++ b/{label}"),
-        format!(
-            "@@ -1,{} +1,{} @@",
-            previous.lines().count(),
-            next.lines().count()
-        ),
-    ];
-    lines.extend(previous.lines().map(|line| format!("-{line}")));
-    lines.extend(next.lines().map(|line| format!("+{line}")));
+    let diff = TextDiff::from_lines(previous, next);
+    let mut lines = vec![format!("--- a/{label}"), format!("+++ b/{label}")];
+
+    for group in diff.grouped_ops(3) {
+        let mut first = true;
+        for op in group {
+            if first {
+                let old_start = op.old_range().start + 1;
+                let old_len = op.old_range().len();
+                let new_start = op.new_range().start + 1;
+                let new_len = op.new_range().len();
+                lines.push(format!(
+                    "@@ -{old_start},{old_len} +{new_start},{new_len} @@"
+                ));
+                first = false;
+            }
+            for change in diff.iter_changes(&op) {
+                let sign = match change.tag() {
+                    ChangeTag::Delete => "-",
+                    ChangeTag::Insert => "+",
+                    ChangeTag::Equal => " ",
+                };
+                let content = change.value().trim_end_matches(&['\r', '\n'][..]);
+                lines.push(format!("{sign}{content}"));
+            }
+        }
+    }
+
     lines.join("\n")
 }
 

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

@@ -258,6 +258,54 @@ impl MintConfig {
         }
     }
 
+    /// Sets the active provider and model, saves the configuration to disk, and logs a system event interaction.
+    pub fn set_active_model(
+        &mut self,
+        provider: &str,
+        model: Option<&str>,
+    ) -> Result<String, ConfigError> {
+        let old_provider = self.ai_provider.clone();
+        let old_active_model = self.active_model().to_string();
+
+        self.ai_provider = provider.to_string();
+        if let Some(m) = model {
+            let m_trimmed = m.trim();
+            if !m_trimmed.is_empty() {
+                match provider {
+                    "anthropic" => self.anthropic_model = m_trimmed.to_string(),
+                    "openai" => self.openai_model = m_trimmed.to_string(),
+                    "openrouter" => self.openrouter_model = m_trimmed.to_string(),
+                    "deepseek" => self.deepseek_model = m_trimmed.to_string(),
+                    "huggingface" => self.hf_model = m_trimmed.to_string(),
+                    "local_openai" => self.local_model_name = m_trimmed.to_string(),
+                    "ollama" => self.ollama_model = m_trimmed.to_string(),
+                    "gemini" => self.gemini_model = m_trimmed.to_string(),
+                    _ => {}
+                }
+            }
+        }
+        save_config(self)?;
+
+        let active_model = self.active_model().to_string();
+        let display_name = format!("{} • {}", self.ai_provider, active_model);
+
+        let changed = old_provider != self.ai_provider || old_active_model != active_model;
+        if changed {
+            if let Ok(memory) = crate::MemoryStore::open_default() {
+                let _ = memory.add_interaction_for_chat_with_fallback(
+                    crate::CHAT_CLI_ID,
+                    &display_name,
+                    "",
+                    "system",
+                    "provider_change",
+                    None,
+                );
+            }
+        }
+
+        Ok(display_name)
+    }
+
     /// Returns the `CustomProvider` whose id matches `provider_key`.
     ///
     /// `provider_key` must be in `"custom:<id>"` format (the leading `"custom:"`
@@ -299,6 +347,76 @@ impl MintConfig {
         }
         providers
     }
+
+    pub fn active_workspace_path(&self) -> Option<PathBuf> {
+        self.extra
+            .get("activeWorkspacePath")
+            .or_else(|| self.extra.get("defaultWorkspacePath"))
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .map(PathBuf::from)
+            .or_else(|| std::env::current_dir().ok())
+    }
+
+    pub fn line_webhook_host(&self) -> String {
+        self.extra
+            .get("lineWebhookHost")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .unwrap_or("127.0.0.1")
+            .to_string()
+    }
+
+    pub fn line_webhook_port(&self) -> u16 {
+        self.extra
+            .get("lineWebhookPort")
+            .and_then(|v| {
+                v.as_u64()
+                    .or_else(|| v.as_str().and_then(|s| s.parse().ok()))
+            })
+            .map(|p| p as u16)
+            .unwrap_or(3000)
+    }
+
+    pub fn whatsapp_webhook_host(&self) -> String {
+        self.extra
+            .get("whatsappWebhookHost")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .unwrap_or("127.0.0.1")
+            .to_string()
+    }
+
+    pub fn whatsapp_webhook_port(&self) -> u16 {
+        self.extra
+            .get("whatsappWebhookPort")
+            .and_then(|v| {
+                v.as_u64()
+                    .or_else(|| v.as_str().and_then(|s| s.parse().ok()))
+            })
+            .map(|p| p as u16)
+            .unwrap_or(3001)
+    }
+
+    pub fn bridge_ack_enabled(&self) -> bool {
+        self.extra
+            .get("enableBridgeAckNotification")
+            .and_then(Value::as_bool)
+            .unwrap_or(true)
+    }
+
+    pub fn bridge_ack_message(&self) -> String {
+        self.extra
+            .get("bridgeAckMessage")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .unwrap_or("[Mint Agent] Remote command received, processing...")
+            .to_string()
+    }
 }
 
 pub fn config_path() -> Result<PathBuf, ConfigError> {