@pheem49/mint 1.8.0 → 1.8.2

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

@@ -93,7 +93,7 @@ pub async fn orchestrate_chat(
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let response = send_chat(config, &enriched).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -122,7 +122,7 @@ where
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let response = stream_chat(config, &enriched, on_chunk).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -147,7 +147,7 @@ pub async fn orchestrate_chat_with_fallback(
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let (response, fallback) = send_chat_with_fallback(config, &enriched).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -176,7 +176,7 @@ where
     let mut resolved_request = request.clone();
     resolved_request.message = resolve_github_links(&request.message, config).await;
     let memory = MemoryStore::open_default()?;
-    let enriched = enrich_request(&memory, &resolved_request)?;
+    let enriched = enrich_request(config, &memory, &resolved_request)?;
     let (response, fallback) = stream_chat_with_fallback(config, &enriched, on_chunk).await?;
     memory.add_interaction_for_chat_with_fallback(
         request_chat_id(request),
@@ -194,7 +194,11 @@ where
     Ok((response, fallback))
 }
 
-fn enrich_request(memory: &MemoryStore, request: &ChatRequest) -> Result<ChatRequest, MemoryError> {
+fn enrich_request(
+    config: &MintConfig,
+    memory: &MemoryStore,
+    request: &ChatRequest,
+) -> Result<ChatRequest, MemoryError> {
     let mut interactions =
         memory.recent_interactions_for_chat(request_chat_id(request), CONTEXT_LIMIT)?;
     interactions.reverse();
@@ -230,6 +234,16 @@ fn enrich_request(memory: &MemoryStore, request: &ChatRequest) -> Result<ChatReq
         .to_owned();
     }
 
+    // Inject active AI model/provider context to system instructions
+    let active_model_info = format!(
+        "\n\n[Active Environment Context]\n\
+         You are running on: {}\n\
+         Using AI Model: {}\n",
+         config.ai_provider,
+         config.active_model()
+    );
+    enriched.system_instruction.push_str(&active_model_info);
+
     if !transcript.is_empty() {
         enriched.system_instruction = format!(
             "{}\n\nRecent conversation context:\n{}",
@@ -253,6 +267,16 @@ fn request_chat_id(request: &ChatRequest) -> &str {
 
 const MAX_STEPS: usize = 32;
 const MAX_OBSERVATION_BYTES: usize = 16_000;
+fn is_port_9222_open() -> bool {
+    use std::net::TcpStream;
+    use std::time::Duration;
+    if let Ok(addr) = "127.0.0.1:9222".parse() {
+        TcpStream::connect_timeout(&addr, Duration::from_millis(50)).is_ok()
+    } else {
+        false
+    }
+}
+
 pub fn build_system_prompt(config: &MintConfig) -> String {
     let mut allowed_actions = vec![
         "list_files",
@@ -284,6 +308,14 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
         "apply_patch",
         "write_file",
     ];
+
+    if is_port_9222_open() {
+        allowed_actions.push("browser_open");
+        allowed_actions.push("browser_click");
+        allowed_actions.push("browser_type");
+        allowed_actions.push("browser_read");
+    }
+
     allowed_actions.retain(|action| !config.disabled_tools.contains(&action.to_string()));
     allowed_actions.push("finish");
 
@@ -319,6 +351,19 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
     if allowed_actions.contains(&"web_search") {
         input_formats.push("- web_search: {\"query\":\"search terms\",\"limit\":5}");
     }
+    if allowed_actions.contains(&"browser_open") {
+        input_formats.push("- browser_open: {\"url\":\"https://example.com\"}");
+    }
+    if allowed_actions.contains(&"browser_click") {
+        input_formats.push("- browser_click: {\"selector\":\"button.submit-btn\"}");
+    }
+    if allowed_actions.contains(&"browser_type") {
+        input_formats
+            .push("- browser_type: {\"selector\":\"input.search-bar\", \"text\":\"search query\"}");
+    }
+    if allowed_actions.contains(&"browser_read") {
+        input_formats.push("- browser_read: {}");
+    }
     if allowed_actions.contains(&"memory_recall") {
         input_formats.push("- memory_recall: {\"query\":\"what did user say about X\"}");
     }
@@ -420,6 +465,20 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
     if allowed_actions.contains(&"web_search") {
         rules.push("7. Use web_search when the user asks to look something up online or needs current information.");
     }
+    if allowed_actions.contains(&"browser_open") {
+        rules.push("7a. Use browser_open to navigate the virtual browser to a URL.");
+    }
+    if allowed_actions.contains(&"browser_click") {
+        rules.push("7b. Use browser_click to click elements on the page.");
+    }
+    if allowed_actions.contains(&"browser_type") {
+        rules.push("7c. Use browser_type to enter text/input into form fields or search boxes.");
+    }
+    if allowed_actions.contains(&"browser_read") {
+        rules.push(
+            "7d. Use browser_read to read the text content of the active page to analyze it.",
+        );
+    }
     if allowed_actions.contains(&"memory_recall") {
         rules.push("8. Use memory_recall to search past interactions before asking the user to repeat context.");
     }
@@ -504,6 +563,10 @@ pub enum ApprovalOutcome {
 pub enum AgentProgress {
     Thinking {
         elapsed_secs: u64,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        agent_name: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        model_name: Option<String>,
     },
     Thought {
         thought: String,
@@ -590,6 +653,12 @@ struct AgentInput {
     title: String,
     #[serde(default)]
     status: String,
+    #[serde(default)]
+    url: String,
+    #[serde(default)]
+    selector: String,
+    #[serde(default)]
+    text: String,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -607,12 +676,95 @@ where
     Ok(Option::<AgentInput>::deserialize(deserializer)?.unwrap_or_default())
 }
 
+fn resolve_agent_config(
+    config: &MintConfig,
+    agent_id: Option<&str>,
+    trajectory: &[String],
+) -> (MintConfig, String, Option<String>, Option<String>) {
+    if !config.enable_agent_collaboration {
+        return (config.clone(), "".to_string(), None, None);
+    }
+
+    let enabled_agents: Vec<&crate::config::AgentConfig> = config.agents.iter().filter(|a| a.enabled).collect();
+    if enabled_agents.is_empty() {
+        return (config.clone(), "".to_string(), None, None);
+    }
+
+    let active_agent = if let Some(id) = agent_id {
+        enabled_agents.iter().find(|a| a.id == id).copied()
+    } else {
+        // Multi-Agent Pipeline Collaboration (Planner -> Coder -> Reviewer)
+        let plan_created = trajectory.iter().any(|step| step.contains("- Action: create_plan"));
+        if !plan_created {
+            if let Some(planner) = enabled_agents.iter().find(|a| a.id == "planner") {
+                Some(*planner)
+            } else {
+                enabled_agents.iter().find(|a| a.id == "coder").copied()
+            }
+        } else {
+            // Check if edits have been made to verify
+            let edits_made = trajectory.iter().any(|step| {
+                step.contains("- Action: write_file") || step.contains("- Action: apply_patch")
+            });
+            if edits_made {
+                if let Some(last_step) = trajectory.last() {
+                    if last_step.contains("- Action: write_file") || last_step.contains("- Action: apply_patch") {
+                        if let Some(reviewer) = enabled_agents.iter().find(|a| a.id == "reviewer") {
+                            Some(*reviewer)
+                        } else {
+                            enabled_agents.iter().find(|a| a.id == "coder").copied()
+                        }
+                    } else {
+                        enabled_agents.iter().find(|a| a.id == "coder").copied()
+                    }
+                } else {
+                    enabled_agents.iter().find(|a| a.id == "coder").copied()
+                }
+            } else {
+                enabled_agents.iter().find(|a| a.id == "coder").copied()
+            }
+        }
+    };
+
+    let Some(agent) = active_agent else {
+        return (config.clone(), "".to_string(), None, None);
+    };
+
+    let mut cfg_clone = config.clone();
+    cfg_clone.ai_provider = agent.provider.clone();
+    cfg_clone.gemini_model = agent.model.clone();
+    cfg_clone.openai_model = agent.model.clone();
+    cfg_clone.anthropic_model = agent.model.clone();
+    cfg_clone.openrouter_model = agent.model.clone();
+    cfg_clone.deepseek_model = agent.model.clone();
+    cfg_clone.hf_model = agent.model.clone();
+    cfg_clone.local_model_name = agent.model.clone();
+    cfg_clone.ollama_model = agent.model.clone();
+
+    if let Some(key) = &agent.api_key {
+        if !key.trim().is_empty() {
+            match agent.provider.as_str() {
+                "gemini" => cfg_clone.api_key = key.clone(),
+                "openai" => cfg_clone.openai_api_key = key.clone(),
+                "anthropic" => cfg_clone.anthropic_api_key = key.clone(),
+                "openrouter" => cfg_clone.openrouter_api_key = key.clone(),
+                "deepseek" => cfg_clone.deepseek_api_key = key.clone(),
+                "huggingface" => cfg_clone.hf_api_key = key.clone(),
+                _ => {}
+            }
+        }
+    }
+
+    (cfg_clone, agent.system_instruction.clone(), Some(agent.name.clone()), Some(agent.model.clone()))
+}
+
 pub async fn orchestrate_agent_loop<Approve, Progress, Chunk>(
     config: &MintConfig,
     task: &str,
     root: &Path,
     image_data_uri: Option<String>,
     chat_id: Option<&str>,
+    agent_id: Option<&str>,
     fast_mode: bool,
     mut approve: Approve,
     mut progress: Progress,
@@ -632,7 +784,7 @@ where
         ))
     })?;
     let resolved_task = resolve_github_links(task, config).await;
-    let skills = crate::skills::learned_skills_context().unwrap_or_default();
+    let skills = crate::skills::learned_skills_context(Some(&root)).unwrap_or_default();
     let mut observation = initial_observation(&resolved_task, &root, &skills);
     let mut pending_image = image_data_uri;
 
@@ -692,20 +844,39 @@ where
     let mut trajectory: Vec<String> = Vec::new();
 
     for step in 1..=MAX_STEPS {
+        let (active_config, agent_instruction, active_agent_name, active_model_name) = resolve_agent_config(config, agent_id, &trajectory);
+
         progress(AgentProgress::Thinking {
             elapsed_secs: started_at.elapsed().as_secs(),
+            agent_name: active_agent_name,
+            model_name: active_model_name.clone(),
         });
 
+        let mut active_system_prompt = system_prompt.clone();
+        if let Some(ref model_name) = active_model_name {
+            active_system_prompt.push_str(&format!(
+                "\n\n[Active Environment Context]\n\
+                 You are running on: {}\n\
+                 Using AI Model: {}\n",
+                 active_config.ai_provider,
+                 model_name
+            ));
+        }
+        if !agent_instruction.is_empty() {
+            active_system_prompt.push_str(&format!("\n\nYour Current Role & System Instructions:\n{}", agent_instruction));
+        }
+
         let (response, fallback) = send_chat_with_fallback(
-            config,
+            &active_config,
             &ChatRequest {
                 message: observation.clone(),
-                system_instruction: system_prompt.clone(),
+                system_instruction: active_system_prompt.clone(),
                 chat_id: Some(chat_id.to_owned()),
                 image_data_uri: pending_image.take(),
                 audio_data_uri: None,
                 document_attachment: None,
                 workspace_path: None,
+                agent_id: None,
             },
         )
         .await?;
@@ -720,7 +891,7 @@ where
             Ok(decision) => decision,
             Err(_) => {
                 let (repaired, _) = send_chat_with_fallback(
-                    config,
+                    &active_config,
                     &ChatRequest {
                         message: format!(
                             "Your previous response was not valid Mint agent JSON.\n\
@@ -728,12 +899,13 @@ where
                              Do not use markdown.\n\nPrevious response:\n{}",
                             truncate(&response.text)
                         ),
-                        system_instruction: system_prompt.clone(),
+                        system_instruction: active_system_prompt.clone(),
                         chat_id: Some(chat_id.to_owned()),
                         image_data_uri: None,
                         audio_data_uri: None,
                         document_attachment: None,
                         workspace_path: None,
+                        agent_id: None,
                     },
                 )
                 .await?;
@@ -1064,7 +1236,7 @@ where
                             .collect::<Vec<_>>()
                             .join("\n");
                         Ok(format!(
-                            "{formatted}\n\nNote: Web search succeeded using {provider} Search. In your finish summary, you MUST state that you found this information using the {provider} Search API (e.g. \"มิ้นท์ค้นหาข้อมูลนี้มาจาก {provider} Search นะคะ\")."
+                            "{formatted}\n\nNote: Web search succeeded using {provider} Search. In your finish summary, you MUST:\n1. Answer the user's question using the information above.\n2. Mention that you found this information via {provider} Search (e.g. \"I found this information using {provider} Search.\").\nDo NOT list sources manually — the UI will display them automatically."
                         ))
                     }
                 }
@@ -1076,6 +1248,91 @@ where
                 )),
             }
         }
+        "browser_open" => {
+            let url = if !input.url.is_empty() {
+                &input.url
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_open requires 'url'".into(),
+                ));
+            };
+            if crate::is_browser_running(config).await {
+                let result = crate::browser::navigate(config, url)
+                    .await
+                    .map_err(|e| OrchestrationError::Agent(e))?;
+                Ok(result)
+            } else {
+                let opened = if cfg!(target_os = "macos") {
+                    std::process::Command::new("open").arg(url).spawn().is_ok()
+                } else if cfg!(target_os = "windows") {
+                    std::process::Command::new("cmd")
+                        .args(&["/C", "start", url])
+                        .spawn()
+                        .is_ok()
+                } else {
+                    std::process::Command::new("xdg-open")
+                        .arg(url)
+                        .spawn()
+                        .is_ok()
+                };
+                if opened {
+                    Ok(format!(
+                        "Mint Auto is not active. Opened {url} in your default browser instead."
+                    ))
+                } else {
+                    Err(OrchestrationError::Agent(
+                        "Failed to open URL in default browser.".into(),
+                    ))
+                }
+            }
+        }
+        "browser_click" => {
+            let selector = if !input.selector.is_empty() {
+                &input.selector
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_click requires 'selector'".into(),
+                ));
+            };
+            let result = crate::browser::click(config, selector)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
+        "browser_type" => {
+            let selector = if !input.selector.is_empty() {
+                &input.selector
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_type requires 'selector'".into(),
+                ));
+            };
+            let text = if !input.text.is_empty() {
+                &input.text
+            } else if !input.query.is_empty() {
+                &input.query
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_type requires 'text'".into(),
+                ));
+            };
+            let result = crate::browser::type_text(config, selector, text)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
+        "browser_read" => {
+            let result = crate::browser::read_page_text(config)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
         "memory_recall" => {
             let query = required(&input.query, "query")?;
             let query_lower = query.to_ascii_lowercase();
@@ -1640,8 +1897,9 @@ fn action_fingerprint(decision: &AgentDecision) -> String {
 }
 
 fn initial_observation(task: &str, root: &Path, skills: &str) -> String {
+    let now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S %Z").to_string();
     let mut observation = format!(
-        "Task: {task}\nWorkspace: {}\nLearned skills:\n{}\n",
+        "Current Time: {now}\nTask: {task}\nWorkspace: {}\nLearned skills:\n{}\n",
         root.display(),
         if skills.trim().is_empty() {
             "(none)"
@@ -1991,6 +2249,7 @@ Example response:
         audio_data_uri: None,
         document_attachment: None,
         workspace_path: None,
+        agent_id: None,
     };
 
     // Send the chat request to LLM
@@ -2049,6 +2308,7 @@ mod tests {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         };
         assert_eq!(
             enrich_request(&store, &request).unwrap().system_instruction,
@@ -2154,4 +2414,49 @@ mod tests {
 
         assert_eq!(classification.mode.as_str(), "readOnly");
     }
+
+    #[test]
+    fn test_resolve_agent_config() {
+        let mut config = MintConfig::default();
+        config.agents = vec![
+            AgentConfig {
+                id: "planner".into(),
+                name: "Planner".into(),
+                provider: "openai".into(),
+                model: "gpt-4o".into(),
+                api_key: Some("test-key".into()),
+                system_instruction: "Planner instruction".into(),
+                enabled: true,
+            },
+            AgentConfig {
+                id: "coder".into(),
+                name: "Coder".into(),
+                provider: "gemini".into(),
+                model: "gemini-2.5-flash".into(),
+                api_key: None,
+                system_instruction: "Coder instruction".into(),
+                enabled: true,
+            },
+        ];
+
+        let (cfg, instr, name, model) = resolve_agent_config(&config, Some("planner"), &[]);
+        assert_eq!(cfg.ai_provider, "openai");
+        assert_eq!(cfg.openai_model, "gpt-4o");
+        assert_eq!(cfg.openai_api_key, "test-key");
+        assert_eq!(instr, "Planner instruction");
+        assert_eq!(name, Some("Planner".to_string()));
+        assert_eq!(model, Some("gpt-4o".to_string()));
+
+        let (cfg, instr, name, model) = resolve_agent_config(&config, None, &[]);
+        assert_eq!(cfg.ai_provider, "openai");
+        assert_eq!(instr, "Planner instruction");
+        assert_eq!(name, Some("Planner".to_string()));
+
+        let trajectory = vec!["Step 1:\n- Action: create_plan\n- Observation: all planned".to_string()];
+        let (cfg, instr, name, model) = resolve_agent_config(&config, None, &trajectory);
+        assert_eq!(cfg.ai_provider, "gemini");
+        assert_eq!(instr, "Coder instruction");
+        assert_eq!(name, Some("Coder".to_string()));
+        assert_eq!(model, Some("gemini-2.5-flash".to_string()));
+    }
 }

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

@@ -53,10 +53,32 @@ pub fn learn_skill(path: &Path) -> Result<LearnedSkill, SkillError> {
     Ok(MemoryStore::open_default()?.add_learned_skill(name, &path.to_string_lossy(), &content)?)
 }
 
-pub fn learned_skills_context() -> Result<String, SkillError> {
-    let skills = MemoryStore::open_default()?.learned_skills(20)?;
-    let value = skills
-        .into_iter()
+pub fn learned_skills_context(workspace_root: Option<&Path>) -> Result<String, SkillError> {
+    let mut skills = MemoryStore::open_default()?.learned_skills(20)?;
+
+    if let Some(home) = dirs::home_dir() {
+        let global_skills_path = home.join(".config").join("mint").join("mint-skills");
+        if !global_skills_path.exists() {
+            let _ = std::fs::create_dir_all(&global_skills_path);
+        }
+        load_skills_from_dir(&global_skills_path, &mut skills);
+    }
+
+    if let Some(root) = workspace_root {
+        let workspace_skills_path1 = root.join(".agents").join("skills");
+        load_skills_from_dir(&workspace_skills_path1, &mut skills);
+
+        let workspace_skills_path2 = root.join("skills");
+        load_skills_from_dir(&workspace_skills_path2, &mut skills);
+    }
+
+    let mut unique_skills = std::collections::BTreeMap::new();
+    for skill in skills {
+        unique_skills.insert(skill.name.clone(), skill);
+    }
+
+    let value = unique_skills
+        .into_values()
         .map(|skill| format!("Skill: {}\n{}", skill.name, skill.content))
         .collect::<Vec<_>>()
         .join("\n\n");
@@ -69,3 +91,90 @@ pub fn learned_skills_context() -> Result<String, SkillError> {
     }
     Ok(format!("{}\n...<learned skills truncated>", &value[..end]))
 }
+
+pub fn load_skills_from_dir(dir: &Path, list: &mut Vec<LearnedSkill>) {
+    if !dir.is_dir() {
+        return;
+    }
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                for filename in &["SKILL.md", "SKILL.txt", "skill.md", "skill.txt"] {
+                    let skill_file = path.join(filename);
+                    if skill_file.is_file() {
+                        if let Ok(content) = fs::read_to_string(&skill_file) {
+                            let name = path
+                                .file_name()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or("skill")
+                                .to_string();
+                            list.push(LearnedSkill {
+                                id: 0,
+                                name,
+                                source_path: skill_file.to_string_lossy().to_string(),
+                                content,
+                                created_at: String::new(),
+                            });
+                        }
+                        break;
+                    }
+                }
+            } else if path.is_file() {
+                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+                    if matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt") {
+                        if let Ok(content) = fs::read_to_string(&path) {
+                            let name = path
+                                .file_stem()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or("skill")
+                                .to_string();
+                            list.push(LearnedSkill {
+                                id: 0,
+                                name,
+                                source_path: path.to_string_lossy().to_string(),
+                                content,
+                                created_at: String::new(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fs_skills_loading() {
+        let test_dir = std::env::temp_dir().join("mint_skills_test_unique_dir");
+        let _ = std::fs::remove_dir_all(&test_dir);
+        let workspace_path = test_dir.join(".agents").join("skills");
+        std::fs::create_dir_all(&workspace_path).unwrap();
+
+        // Write a file skill
+        let file_skill_path = workspace_path.join("rust-style.md");
+        std::fs::write(&file_skill_path, "Use 4 spaces for Rust indent.").unwrap();
+
+        // Write a directory skill
+        let dir_skill_path = workspace_path.join("js-style");
+        std::fs::create_dir_all(&dir_skill_path).unwrap();
+        std::fs::write(dir_skill_path.join("SKILL.md"), "Use 2 spaces for JS.").unwrap();
+
+        let mut list = Vec::new();
+        load_skills_from_dir(&workspace_path, &mut list);
+
+        let _ = std::fs::remove_dir_all(&test_dir);
+
+        assert_eq!(list.len(), 2);
+
+        let rust_skill = list.iter().find(|s| s.name == "rust-style").unwrap();
+        assert_eq!(rust_skill.content, "Use 4 spaces for Rust indent.");
+
+        let js_skill = list.iter().find(|s| s.name == "js-style").unwrap();
+        assert_eq!(js_skill.content, "Use 2 spaces for JS.");
+    }
+}

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

@@ -10,6 +10,8 @@ pub struct TtsUrl {
 }
 
 pub fn google_tts_urls(text: &str, language: &str) -> Vec<TtsUrl> {
+    let has_thai = text.chars().any(|c| ('\u{0e00}'..='\u{0e7f}').contains(&c));
+    let tl = if has_thai { "th" } else { language };
     let chunks = split_text(text, MAX_GOOGLE_TTS_CHARS);
     let total = chunks.len();
     chunks
@@ -19,7 +21,7 @@ pub fn google_tts_urls(text: &str, language: &str) -> Vec<TtsUrl> {
             url: format!(
                 "https://translate.google.com/translate_tts?ie=UTF-8&q={}&tl={}&client=tw-ob&idx={index}&total={total}&textlen={}",
                 encode_component(&chunk),
-                encode_component(language),
+                encode_component(tl),
                 chunk.chars().count()
             ),
             short_text: chunk,

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

@@ -51,28 +51,7 @@ pub fn load_workflows() -> Result<Vec<Value>, WorkflowError> {
 fn save_default_workflows(path: &PathBuf) -> Result<(), WorkflowError> {
     let directory = path.parent().ok_or(WorkflowError::MissingDirectory)?;
     fs::create_dir_all(directory).map_err(WorkflowError::CreateDirectory)?;
-    let workflows = json!([
-        {
-            "id": "wf-1",
-            "name": "Check Mic on Zoom",
-            "trigger": { "type": "process_running", "processName": "zoom" },
-            "action": {
-                "type": "system_info",
-                "message": "Looks like you opened Zoom. Should I check your system resources?",
-                "target": ""
-            }
-        },
-        {
-            "id": "wf-2",
-            "name": "Coding Time",
-            "trigger": { "type": "process_running", "processName": "code" },
-            "action": {
-                "type": "open_app",
-                "message": "Coding time. Want me to open Spotify?",
-                "target": "spotify"
-            }
-        }
-    ]);
+    let workflows = json!([]);
     let raw = serde_json::to_string_pretty(&workflows).map_err(WorkflowError::Serialize)?;
     fs::write(path, format!("{raw}\n")).map_err(|source| WorkflowError::Write {
         path: path.clone(),