@pheem49/mint 1.8.2 → 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

@@ -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)
@@ -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>,
@@ -230,6 +232,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 +262,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 {
@@ -280,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()?
@@ -708,6 +716,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,17 +831,33 @@ 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());
+    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(()),
-        _ if has_image || has_audio => Err(ChatError::UnsupportedAttachments(provider.into())),
+        // Custom providers are text-only for now; reject any multimodal content.
+        p if p.starts_with("custom:") => {
+            if has_image || has_audio || has_video {
+                Err(ChatError::UnsupportedAttachments(provider.into()))
+            } else {
+                Ok(())
+            }
+        }
+        _ if has_image || has_audio || has_video => {
+            Err(ChatError::UnsupportedAttachments(provider.into()))
+        }
         _ => Ok(()),
     }
 }
@@ -920,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)
 }
 
@@ -933,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!(
@@ -965,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")
 }
 
@@ -536,18 +554,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 +575,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();
         }
     }