@pheem49/mint 1.9.0 → 1.10.0

package/src/renderer/src-web/tauri.ts

@@ -57,6 +57,40 @@ export async function getRuntimeStatus(): Promise<RuntimeStatus> {
   return invoke<RuntimeStatus>('get_runtime_status')
 }
 
+export async function setActiveModel(provider: string, model?: string): Promise<string> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    const API_BASE = getApiBase()
+    try {
+      const res = await fetch(`${API_BASE}/active-model`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ provider, model }),
+      })
+      const data = await res.json()
+      return data.displayName || `Changed model to ${provider}`
+    } catch (e) {
+      console.error('Failed to set active model via API:', e)
+      return `Changed model to ${provider}`
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<string>('set_active_model', { provider, model })
+}
+
+export async function uploadFile(file: File): Promise<string> {
+  const API_BASE = getApiBase();
+  const res = await fetch(`${API_BASE}/uploads?filename=${encodeURIComponent(file.name)}`, {
+    method: 'POST',
+    body: file,
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => null);
+    throw new Error(data?.error || `HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data.url;
+}
+
 export interface DetectedTools {
   docker: boolean
   git: boolean
@@ -83,19 +117,20 @@ export async function sendChatMessage(
   message: string,
   imageDataUri?: string | null,
   audioDataUri?: string | null,
+  videoDataUri?: string | null,
   documentAttachment?: DocumentAttachment | null,
   workspacePath?: string | null,
   chatId?: string | null,
   agentId?: string | null,
 ): Promise<ChatResponse> {
-  const outgoingMessage = withImagePlaceholder(message, imageDataUri)
+  const outgoingMessage = withImagePlaceholder(message, imageDataUri, videoDataUri)
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     const API_BASE = getApiBase();
     try {
       const res = await fetch(`${API_BASE}/chat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
+        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, agentId })
       });
       const data = await res.json().catch(() => null);
       if (!res.ok) {
@@ -120,7 +155,7 @@ export async function sendChatMessage(
   }
   const { invoke } = await import('@tauri-apps/api/core')
   const response = await invoke<ChatResponse>('send_chat_message', {
-    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
+    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, agentId },
   })
   if (imageDataUri) {
     await invoke('save_pictures', {
@@ -129,6 +164,13 @@ export async function sendChatMessage(
       message: outgoingMessage,
     })
   }
+  if (videoDataUri) {
+    await invoke('save_pictures', {
+      images: videoDataUri.split(' '),
+      source: 'chat',
+      message: outgoingMessage,
+    })
+  }
   return response
 }
 
@@ -137,6 +179,7 @@ export async function streamChatMessage(
   onChunk: (chunk: string) => void,
   imageDataUri?: string | null,
   audioDataUri?: string | null,
+  videoDataUri?: string | null,
   systemInstruction = '',
   onProgress?: (progress: AgentProgress) => void,
   documentAttachment?: DocumentAttachment | null,
@@ -146,11 +189,11 @@ export async function streamChatMessage(
 ): Promise<ChatResponse> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     const API_BASE = getApiBase();
-    const outgoingMessage = withImagePlaceholder(message, imageDataUri);
+    const outgoingMessage = withImagePlaceholder(message, imageDataUri, videoDataUri);
     const res = await fetch(`${API_BASE}/chat-stream`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
+      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, agentId })
     });
     if (!res.ok) {
       const data = await res.json().catch(() => null);
@@ -189,14 +232,14 @@ export async function streamChatMessage(
     throw new Error("Stream closed without a final response");
   }
   const { invoke, Channel } = await import('@tauri-apps/api/core')
-  const outgoingMessage = withImagePlaceholder(message, imageDataUri)
+  const outgoingMessage = withImagePlaceholder(message, imageDataUri, videoDataUri)
   const onEvent = new Channel<DesktopStreamEvent>()
   onEvent.onmessage = (event) => {
     if (event.type === 'chunk') onChunk(event.chunk)
     else onProgress?.(event.progress)
   }
   const response = await invoke<ChatResponse>('stream_chat_message', {
-    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
+    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, agentId },
     onEvent,
   })
   if (imageDataUri) {
@@ -206,14 +249,29 @@ export async function streamChatMessage(
       message: outgoingMessage,
     })
   }
+  if (videoDataUri) {
+    await invoke('save_pictures', {
+      images: videoDataUri.split(' '),
+      source: 'chat',
+      message: outgoingMessage,
+    })
+  }
   return response
 }
 
-function withImagePlaceholder(message: string, imageDataUri?: string | null) {
-  if (!imageDataUri || message.includes('[Image #1]')) return message
-  const imageCount = imageDataUri.split(/\s+/).filter(Boolean).length
-  const markers = Array.from({ length: imageCount }, (_, index) => `[Image #${index + 1}]`).join(' ')
-  return markers ? `${message} ${markers}` : message
+function withImagePlaceholder(message: string, imageDataUri?: string | null, videoDataUri?: string | null) {
+  let finalMessage = message
+  if (imageDataUri && !finalMessage.includes('[Image #1]')) {
+    const imageCount = imageDataUri.split(/\s+/).filter(Boolean).length
+    const markers = Array.from({ length: imageCount }, (_, index) => `[Image #${index + 1}]`).join(' ')
+    if (markers) finalMessage = `${finalMessage} ${markers}`
+  }
+  if (videoDataUri && !finalMessage.includes('[Video #1]')) {
+    const videoCount = videoDataUri.split(/\s+/).filter(Boolean).length
+    const markers = Array.from({ length: videoCount }, (_, index) => `[Video #${index + 1}]`).join(' ')
+    if (markers) finalMessage = `${finalMessage} ${markers}`
+  }
+  return finalMessage
 }
 
 export async function getTtsUrls(text: string): Promise<TtsUrl[]> {
@@ -257,6 +315,7 @@ export async function getRecentInteractions(limit = 50, chatId?: string | null):
 export async function saveSystemInteraction(
   chatId: string,
   userText: string,
+  aiText: string,
   provider: string,
   model: string,
 ): Promise<any> {
@@ -266,7 +325,7 @@ export async function saveSystemInteraction(
       const res = await fetch(`${API_BASE}/interactions`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ chatId, userText, provider, model }),
+        body: JSON.stringify({ chatId, userText, aiText, provider, model }),
       });
       return await res.json();
     } catch (e) {
@@ -275,7 +334,7 @@ export async function saveSystemInteraction(
     }
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('save_system_interaction', { chatId, userText, provider, model })
+  return invoke('save_system_interaction', { chatId, userText, aiText, provider, model })
 }
 
 export async function saveInteractionAgentActivity(
@@ -972,7 +1031,7 @@ export function installTauriAdapters() {
   }
 
   window.api = {
-    sendMessage: (message, imageDataUri, audioDataUri, documentAttachment) => sendChatMessage(message, imageDataUri, audioDataUri, documentAttachment),
+    sendMessage: (message, imageDataUri, audioDataUri, documentAttachment) => sendChatMessage(message, imageDataUri, audioDataUri, undefined, documentAttachment),
     closeWindow: async () => {
       const { invoke } = await import('@tauri-apps/api/core')
       const { getCurrentWindow } = await import('@tauri-apps/api/window')
@@ -1119,13 +1178,18 @@ async function captureSharedScreen(): Promise<string> {
 export async function listLearnedSkills(workspacePath?: string): Promise<LearnedSkill[]> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     try {
+      const API_BASE = getLocalApiBase()
+      const res = await fetch(`${API_BASE}/learned-skills`)
+      if (res.ok) {
+        return await res.json()
+      }
       const val = await getProfileValue('learned-skills-web-mock')
       if (val) {
         return JSON.parse(val)
       }
       return []
     } catch (e) {
-      console.error("Failed to load web mock skills:", e)
+      console.error("Failed to load web skills:", e)
       return []
     }
   }
@@ -1230,6 +1294,61 @@ export async function readClipboardImage(): Promise<string | null> {
   }
 }
 
+// ─── Veo Studio — Video Generation (stub; real Tauri command in follow-up) ───
+
+export interface VideoGenRequest {
+  prompt: string
+  negativePrompt?: string
+  aspectRatio: '16:9' | '9:16' | '1:1'
+  duration: 5 | 8
+  model?: string
+  provider: string
+}
+
+export interface VideoGenEntry {
+  id: string
+  url: string
+  path: string
+  message?: string
+  createdAt?: string
+}
+
+export interface VideoGenResponse {
+  videos: VideoGenEntry[]
+  provider: string
+  model: string
+  description?: string
+}
+
+export interface VideoGenProviders {
+  active: string
+  available: string[]
+}
+
+/**
+ * Generate a video using the configured provider.
+ * NOTE: This is a frontend stub — the real Tauri backend command will be
+ * added in a follow-up PR once the Veo REST API integration is ready.
+ */
+export async function generateVideo(request: VideoGenRequest): Promise<VideoGenResponse> {
+  const apiBase = getLocalApiBase()
+  const response = await fetch(`${apiBase}/video-generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request)
+  })
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}))
+    throw new Error(errorData.error || `HTTP ${response.status} from API`)
+  }
+  return response.json()
+}
+
+export async function getVideoGenProviders(): Promise<VideoGenProviders> {
+  return { active: 'veo', available: ['veo'] }
+}
+
+
 // Enforce compile-time check against the shared platform interface
 const _apiCheck: MintPlatformApi = {
   getRuntimeStatus,

package/src-tauri/src/lib.rs

@@ -31,11 +31,11 @@ use integrations::{channel_inventory, list_plugins};
 use mint_core::{
     AgentApproval, AgentProgress, AppliedCodeEdit, ApprovalOutcome, ChatRequest, ChatResponse,
     ChatSession, CodeEdit, CodeEditProposal, ImageGenRequest, InteractionMemory, MemoryStore,
-    MintConfig, PictureEntry, TtsUrl, WeatherReport, apply_code_edits, classify_shell_command,
-    config_path, google_tts_urls, list_saved_pictures, load_config, load_workflows,
-    orchestrate_agent_loop, orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
-    propose_code_edits, save_chat_images, save_config, save_workflows, start_channels, weather,
-    workflows_path,
+    MintConfig, PictureEntry, TtsUrl, VideoGenRequest, VideoGenResponse, WeatherReport,
+    apply_code_edits, classify_shell_command, config_path, google_tts_urls, list_saved_pictures,
+    load_config, load_workflows, orchestrate_agent_loop, orchestrate_chat_stream_with_fallback,
+    orchestrate_chat_with_fallback, propose_code_edits, save_chat_images, save_config,
+    save_workflows, start_channels, weather, workflows_path,
 };
 use plugins::execute_plugin;
 
@@ -73,6 +73,7 @@ struct RuntimeStatus {
     backend: &'static str,
     config_path: String,
     active_provider: String,
+    active_model: String,
     available_providers: Vec<String>,
     integrations: Value,
 }
@@ -119,6 +120,7 @@ fn get_runtime_status() -> Result<RuntimeStatus, String> {
             .display()
             .to_string(),
         active_provider: config.ai_provider.clone(),
+        active_model: config.active_model().to_string(),
         available_providers: config.available_providers(),
         integrations: integration_status(&config),
     })
@@ -305,6 +307,20 @@ fn update_config(app: AppHandle, config: MintConfig) -> Result<(), String> {
     Ok(())
 }
 
+#[tauri::command]
+fn set_active_model(
+    app: AppHandle,
+    provider: String,
+    model: Option<String>,
+) -> Result<String, String> {
+    let mut config = load_config().map_err(|error| error.to_string())?;
+    let display_name = config
+        .set_active_model(&provider, model.as_deref())
+        .map_err(|error| error.to_string())?;
+    let _ = app.emit("settings-changed", &config);
+    Ok(display_name)
+}
+
 #[tauri::command]
 fn inspect_shell_command(command: String) -> mint_core::ShellClassification {
     classify_shell_command(&command)
@@ -312,7 +328,21 @@ fn inspect_shell_command(command: String) -> mint_core::ShellClassification {
 
 #[tauri::command]
 async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatResponse, String> {
-    let config = load_config().map_err(|error| error.to_string())?;
+    let mut config = load_config().map_err(|error| error.to_string())?;
+    if let Some(ref path) = request.workspace_path {
+        if !path.trim().is_empty()
+            && config
+                .extra
+                .get("activeWorkspacePath")
+                .and_then(Value::as_str)
+                != Some(path.as_str())
+        {
+            config
+                .extra
+                .insert("activeWorkspacePath".into(), Value::String(path.clone()));
+            let _ = save_config(&config);
+        }
+    }
     let request = request.with_document_context(&config)?;
 
     if request.message.starts_with("/chat ") {
@@ -392,6 +422,7 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
     let message_clone = request.message.clone();
     let root_clone = root.clone();
     let image_data_uri_clone = request.image_data_uri.clone();
+    let video_data_uri_clone = request.video_data_uri.clone();
     let chat_id_clone = request.chat_id.clone();
     let agent_id_clone = request.agent_id.clone();
 
@@ -401,6 +432,7 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
             &message_clone,
             &root_clone,
             image_data_uri_clone,
+            video_data_uri_clone,
             chat_id_clone.as_deref(),
             agent_id_clone.as_deref(),
             fast_mode,
@@ -449,7 +481,21 @@ async fn stream_chat_message(
     request: ChatRequest,
     on_event: Channel<DesktopStreamEvent>,
 ) -> Result<ChatResponse, String> {
-    let config = load_config().map_err(|error| error.to_string())?;
+    let mut config = load_config().map_err(|error| error.to_string())?;
+    if let Some(ref path) = request.workspace_path {
+        if !path.trim().is_empty()
+            && config
+                .extra
+                .get("activeWorkspacePath")
+                .and_then(Value::as_str)
+                != Some(path.as_str())
+        {
+            config
+                .extra
+                .insert("activeWorkspacePath".into(), Value::String(path.clone()));
+            let _ = save_config(&config);
+        }
+    }
     let request = request.with_document_context(&config)?;
 
     if request.message.starts_with("/chat ") {
@@ -548,6 +594,7 @@ async fn stream_chat_message(
     let message_clone = request.message.clone();
     let root_clone = root.clone();
     let image_data_uri_clone = request.image_data_uri.clone();
+    let video_data_uri_clone = request.video_data_uri.clone();
     let chat_id_clone = request.chat_id.clone();
     let agent_id_clone = request.agent_id.clone();
 
@@ -557,6 +604,7 @@ async fn stream_chat_message(
             &message_clone,
             &root_clone,
             image_data_uri_clone,
+            video_data_uri_clone,
             chat_id_clone.as_deref(),
             agent_id_clone.as_deref(),
             fast_mode,
@@ -624,12 +672,19 @@ fn save_interaction_agent_activity(
 fn save_system_interaction(
     chat_id: String,
     user_text: String,
+    ai_text: Option<String>,
     provider: String,
     model: String,
 ) -> Result<i64, String> {
     MemoryStore::open_default()
         .and_then(|memory| {
-            memory.add_interaction_for_chat(&chat_id, &user_text, "", &provider, &model)
+            memory.add_interaction_for_chat(
+                &chat_id,
+                &user_text,
+                ai_text.as_deref().unwrap_or(""),
+                &provider,
+                &model,
+            )
         })
         .map_err(|error| error.to_string())
 }
@@ -704,6 +759,9 @@ fn list_learned_skills(workspace_path: Option<String>) -> Result<Vec<LearnedSkil
 
     let mut global_skills = Vec::new();
     if let Some(home) = dirs::home_dir() {
+        let global_agents_path = home.join(".gemini").join("config").join("AGENTS.md");
+        mint_core::skills::load_agent_rules_file(&global_agents_path, &mut global_skills);
+
         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);
@@ -713,6 +771,12 @@ fn list_learned_skills(workspace_path: Option<String>) -> Result<Vec<LearnedSkil
 
     let mut workspace_skills = Vec::new();
     if let Ok(root) = workspace_root(workspace_path.as_deref()) {
+        let workspace_agents_path1 = root.join(".agents").join("AGENTS.md");
+        mint_core::skills::load_agent_rules_file(&workspace_agents_path1, &mut workspace_skills);
+
+        let workspace_agents_path2 = root.join("AGENTS.md");
+        mint_core::skills::load_agent_rules_file(&workspace_agents_path2, &mut workspace_skills);
+
         let workspace_skills_path1 = root.join(".agents").join("skills");
         mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut workspace_skills);
 
@@ -867,6 +931,14 @@ async fn generate_images(request: ImageGenRequest) -> Result<DesktopImageGenResp
     })
 }
 
+#[tauri::command]
+async fn generate_video(request: VideoGenRequest) -> Result<VideoGenResponse, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    mint_core::generate_video(&config, &request)
+        .await
+        .map_err(|error| error.to_string())
+}
+
 #[tauri::command]
 fn list_pictures() -> Result<Vec<PictureEntry>, String> {
     list_saved_pictures().map_err(|error| error.to_string())
@@ -881,6 +953,37 @@ fn save_pictures(
     save_chat_images(images, source, message).map_err(|error| error.to_string())
 }
 
+#[tauri::command]
+fn upload_file(filename: String, data_b64: String) -> Result<String, String> {
+    // Determine mime from filename
+    let mime = filename
+        .rsplit_once('.')
+        .map(|(_, ext)| match ext.to_ascii_lowercase().as_str() {
+            "mp4" => "video/mp4",
+            "webm" => "video/webm",
+            "mov" => "video/quicktime",
+            "mkv" => "video/x-matroska",
+            "avi" => "video/x-msvideo",
+            _ => "application/octet-stream",
+        })
+        .unwrap_or("application/octet-stream");
+
+    let data_uri = format!("data:{};base64,{}", mime, data_b64);
+    match save_chat_images(
+        vec![data_uri],
+        Some("upload".into()),
+        Some("uploaded".into()),
+    ) {
+        Ok(mut saved) => {
+            if let Some(entry) = saved.pop() {
+                return Ok(format!("/api/pictures/{}", entry.filename));
+            }
+            Err("no entry saved".into())
+        }
+        Err(e) => Err(e.to_string()),
+    }
+}
+
 #[tauri::command]
 fn open_folder(path: String) -> Result<ActionResult, String> {
     let target_path = PathBuf::from(path.trim());
@@ -1241,12 +1344,14 @@ pub fn run() {
             create_workspace_folder,
             delete_workspace_item,
             generate_images,
+            generate_video,
             select_workspace_directory,
             get_config,
             get_updater_status,
             check_for_updates,
             install_available_update,
             update_config,
+            set_active_model,
             inspect_shell_command,
             send_chat_message,
             stream_chat_message,
@@ -1265,6 +1370,7 @@ pub fn run() {
             delete_learned_skill,
             list_pictures,
             save_pictures,
+            upload_file,
             open_folder,
             get_tts_urls,
             get_weather,

package/src-tauri/src/webhooks.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use base64::{Engine as _, engine::general_purpose::STANDARD};
 use hmac::{Hmac, Mac};
-use mint_core::{ChatRequest, load_config, orchestrate_chat};
+use mint_core::load_config;
 use serde_json::{Value, json};
 use sha2::Sha256;
 use tokio::{
@@ -14,10 +14,16 @@ type HmacSha256 = Hmac<Sha256>;
 
 pub fn start_webhooks() {
     tauri::async_runtime::spawn(async {
-        let _ = serve(3000, Service::Line).await;
+        let (host, port) = load_config()
+            .map(|c| (c.line_webhook_host(), c.line_webhook_port()))
+            .unwrap_or_else(|_| ("127.0.0.1".into(), 3000));
+        let _ = serve(&host, port, Service::Line).await;
     });
     tauri::async_runtime::spawn(async {
-        let _ = serve(3001, Service::Whatsapp).await;
+        let (host, port) = load_config()
+            .map(|c| (c.whatsapp_webhook_host(), c.whatsapp_webhook_port()))
+            .unwrap_or_else(|_| ("127.0.0.1".into(), 3001));
+        let _ = serve(&host, port, Service::Whatsapp).await;
     });
 }
 
@@ -27,8 +33,9 @@ enum Service {
     Whatsapp,
 }
 
-async fn serve(port: u16, service: Service) -> Result<(), String> {
-    let listener = TcpListener::bind(("127.0.0.1", port))
+async fn serve(host: &str, port: u16, service: Service) -> Result<(), String> {
+    let addr = format!("{host}:{port}");
+    let listener = TcpListener::bind(&addr)
         .await
         .map_err(|error| error.to_string())?;
     loop {
@@ -78,9 +85,28 @@ async fn handle_line(request: HttpRequest) -> Result<(&'static str, String), Str
         ) else {
             continue;
         };
-        let answer = answer(text, "Reply concisely for a LINE chat.").await;
-        let _ = mint_core::HTTP_CLIENT.clone().post("https://api.line.me/v2/bot/message/reply").bearer_auth(&token)
-            .json(&json!({ "replyToken": reply_token, "messages": [{ "type": "text", "text": answer }] })).send().await;
+        let user_id = event["source"]["userId"].as_str().unwrap_or("unknown");
+        let formatted_chat_id = format!("line:{user_id}");
+        let answer = mint_core::channels::answer_channel(
+            text,
+            "Reply concisely for a LINE chat.",
+            Some(formatted_chat_id),
+        )
+        .await;
+
+        let mut messages = Vec::new();
+        if config.bridge_ack_enabled() {
+            messages.push(json!({ "type": "text", "text": config.bridge_ack_message() }));
+        }
+        messages.push(json!({ "type": "text", "text": answer }));
+
+        let _ = mint_core::HTTP_CLIENT
+            .clone()
+            .post("https://api.line.me/v2/bot/message/reply")
+            .bearer_auth(&token)
+            .json(&json!({ "replyToken": reply_token, "messages": messages }))
+            .send()
+            .await;
     }
     Ok(("200 OK", "ok".into()))
 }
@@ -133,35 +159,23 @@ async fn handle_whatsapp(request: HttpRequest) -> Result<(&'static str, String),
         else {
             continue;
         };
-        let answer = answer(text, "Reply concisely for a WhatsApp chat.").await;
+        if config.bridge_ack_enabled() {
+            let _ = mint_core::HTTP_CLIENT.clone().post(format!("https://graph.facebook.com/v23.0/{phone_id}/messages")).bearer_auth(&access_token)
+                .json(&json!({ "messaging_product": "whatsapp", "to": to, "type": "text", "text": { "body": config.bridge_ack_message() } })).send().await;
+        }
+        let formatted_chat_id = format!("whatsapp:{to}");
+        let answer = mint_core::channels::answer_channel(
+            text,
+            "Reply concisely for a WhatsApp chat.",
+            Some(formatted_chat_id),
+        )
+        .await;
         let _ = mint_core::HTTP_CLIENT.clone().post(format!("https://graph.facebook.com/v23.0/{phone_id}/messages")).bearer_auth(&access_token)
             .json(&json!({ "messaging_product": "whatsapp", "to": to, "type": "text", "text": { "body": answer } })).send().await;
     }
     Ok(("200 OK", "ok".into()))
 }
 
-async fn answer(text: &str, system: &str) -> String {
-    let Ok(config) = load_config() else {
-        return "Mint config error".into();
-    };
-    orchestrate_chat(
-        &config,
-        &ChatRequest {
-            message: text.into(),
-            system_instruction: system.into(),
-            chat_id: None,
-            image_data_uri: None,
-            audio_data_uri: None,
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-        },
-    )
-    .await
-    .map(|response| response.text)
-    .unwrap_or_else(|error| format!("Mint error: {error}"))
-}
-
 struct HttpRequest {
     method: String,
     path: String,

package/src-tauri/src/workflows.rs

@@ -79,6 +79,7 @@ pub fn start_monitor(app: AppHandle) {
                             chat_id: None,
                             image_data_uri: None,
                             audio_data_uri: None,
+                            video_data_uri: None,
                             document_attachment: None,
                             workspace_path: None,
                             agent_id: None,

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Mint",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "identifier": "com.pheem49.mint",
   "build": {
     "beforeDevCommand": "npm run dev:desktop",

package/temp_gridgeist/AGENTS.md

@@ -0,0 +1,8 @@
+# Project instructions
+
+- Do not use any `superpowers:*` skills in this repository.
+- Do not create or restore files under `docs/superpowers/`.
+- Use the `solodeveling` skill at the start of every task in this repository. Resume `.solodeveling/state.md` when present and let the skill route the work to the smallest relevant lifecycle workflow.
+- Keep one primary agent. Do not use subagents unless the user explicitly requests delegation.
+- If `solodeveling` is unavailable, state that briefly and continue with the same evidence-driven lifecycle rather than blocking routine work.
+- Work directly from the user's request and use only the minimum additional relevant skills.