@pheem49/mint 1.8.1 → 1.9.0

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

@@ -1,106 +1,29 @@
-export interface RuntimeStatus {
-  backend: string
-  configPath: string
-  activeProvider: string
-  availableProviders: string[]
-  integrations: Record<string, unknown>
-  localIp?: string
-}
-
-export interface ChatResponse {
-  provider: string
-  model: string
-  text: string
-  fallbackProvider?: string | null
-}
+export * from '../shared/types'
+import type { MintPlatformApi } from '../shared/platform'
+import type {
 
-export interface TtsUrl {
-  shortText: string
-  url: string
-}
-
-export interface DocumentAttachment {
-  filename: string
-  dataUri: string
-}
+  RuntimeStatus,
+  ChatResponse,
+  TtsUrl,
+  DocumentAttachment,
+  AgentProgress,
+  InteractionMemory,
+  ChatSession,
+  PictureEntry,
+  ImageGenRequest,
+  ImageGenProviders,
+  ImageGenResponse,
+  WorkspaceTreeEntry,
+  CodeEdit,
+  CodeEditProposal,
+  LearnedSkill,
+} from '../shared/types'
 
-export type AgentProgress =
-  | { type: 'Thinking'; data: { elapsed_secs: number } }
-  | { type: 'Thought'; data: { thought: string } }
-  | { type: 'ToolStart'; data: { action: string; input: Record<string, unknown> } }
-  | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string } }
 
 type DesktopStreamEvent =
   | { type: 'chunk'; chunk: string }
   | { type: 'progress'; progress: AgentProgress }
 
-export interface InteractionMemory {
-  id: number
-  chatId: string
-  userText: string
-  aiText: string
-  provider: string
-  model: string
-  fallbackProvider?: string | null
-  createdAt: string
-  agentActivity?: AgentProgress[] | null
-}
-
-export interface ChatSession {
-  id: string
-  title: string
-  kind: string
-  createdAt: string
-  updatedAt: string
-}
-
-export interface PictureEntry {
-  id: string
-  filename: string
-  path: string
-  mimeType: string
-  createdAt: string
-  source: string
-  message: string
-  thumbnailPath?: string
-  url?: string
-  thumbnailUrl?: string
-}
-
-export interface ImageGenRequest {
-  prompt: string
-  negativePrompt?: string
-  aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3'
-  numImages?: number
-  model?: string
-  /** Which image generation provider to use. Falls back to config default when omitted. */
-  provider?: string
-}
-
-export interface ImageGenProviders {
-  active: string
-  available: string[]
-}
-
-export interface ImageGenResponse {
-  images: PictureEntry[]
-  model: string
-  provider: string
-  prompt: string
-  description?: string | null
-}
-
-
-export interface CodeEdit {
-  path: string
-  content: string
-}
-
-export interface CodeEditProposal {
-  approvalRequired: boolean
-  approvalToken: string
-  edits: Array<{ path: string; existed: boolean; diff: string }>
-}
 
 export const isTauriRuntime = () => (
   typeof window !== 'undefined' && Boolean((window as any).__TAURI_INTERNALS__)
@@ -163,6 +86,7 @@ export async function sendChatMessage(
   documentAttachment?: DocumentAttachment | null,
   workspacePath?: string | null,
   chatId?: string | null,
+  agentId?: string | null,
 ): Promise<ChatResponse> {
   const outgoingMessage = withImagePlaceholder(message, imageDataUri)
   if (typeof window === 'undefined' || !isTauriRuntime()) {
@@ -171,7 +95,7 @@ export async function sendChatMessage(
       const res = await fetch(`${API_BASE}/chat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment })
+        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
       });
       const data = await res.json().catch(() => null);
       if (!res.ok) {
@@ -196,7 +120,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 },
+    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
   })
   if (imageDataUri) {
     await invoke('save_pictures', {
@@ -218,6 +142,7 @@ export async function streamChatMessage(
   documentAttachment?: DocumentAttachment | null,
   workspacePath?: string | null,
   chatId?: string | null,
+  agentId?: string | null,
 ): Promise<ChatResponse> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     const API_BASE = getApiBase();
@@ -225,7 +150,7 @@ export async function streamChatMessage(
     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 })
+      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
     });
     if (!res.ok) {
       const data = await res.json().catch(() => null);
@@ -271,7 +196,7 @@ export async function streamChatMessage(
     else onProgress?.(event.progress)
   }
   const response = await invoke<ChatResponse>('stream_chat_message', {
-    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath },
+    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
     onEvent,
   })
   if (imageDataUri) {
@@ -298,6 +223,20 @@ export async function getTtsUrls(text: string): Promise<TtsUrl[]> {
   return invoke<TtsUrl[]>('get_tts_urls', { text })
 }
 
+export async function cancelChatMessage(chatId: string): Promise<void> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    const API_BASE = getApiBase();
+    await fetch(`${API_BASE}/cancel-chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chatId })
+    });
+    return;
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('cancel_chat_message', { chatId })
+}
+
 export async function getRecentInteractions(limit = 50, chatId?: string | null): Promise<InteractionMemory[]> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     const API_BASE = getApiBase();
@@ -476,11 +415,12 @@ export async function listSavedPictures(): Promise<PictureEntry[]> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     const API_BASE = getApiBase();
     try {
-      const res = await fetch(`${API_BASE}/pictures`);
+      const res = await fetch(`${API_BASE}/pictures?_t=${Date.now()}`);
       const pictures = await res.json();
+      const timestamp = Date.now();
       return Array.isArray(pictures)
         ? pictures.map((picture) => {
-            const pictureUrl = picture.url ? `${API_BASE.replace('/api', '')}${picture.url}` : undefined
+            const pictureUrl = picture.url ? `${API_BASE.replace('/api', '')}${picture.url}?_t=${timestamp}` : undefined
             return {
               ...picture,
               path: pictureUrl || picture.path,
@@ -1176,8 +1116,109 @@ async function captureSharedScreen(): Promise<string> {
   }
 }
 
+export async function listLearnedSkills(workspacePath?: string): Promise<LearnedSkill[]> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    try {
+      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)
+      return []
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<LearnedSkill[]>('list_learned_skills', { workspacePath })
+}
+
+export async function addLearnedSkill(name: string, content: string): Promise<LearnedSkill> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    try {
+      const list = await listLearnedSkills()
+      const newSkill: LearnedSkill = {
+        id: Date.now(),
+        name,
+        sourcePath: 'ui_manual',
+        content,
+        updatedAt: new Date().toISOString()
+      }
+      list.push(newSkill)
+      await setProfileValue('learned-skills-web-mock', JSON.stringify(list))
+      return newSkill
+    } catch (e) {
+      console.error("Failed to add web mock skill:", e)
+      throw e
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<LearnedSkill>('add_learned_skill', { name, content })
+}
+
+export async function deleteLearnedSkill(name: string): Promise<number> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    try {
+      const list = await listLearnedSkills()
+      const filtered = list.filter(s => s.name !== name)
+      const deletedCount = list.length - filtered.length
+      await setProfileValue('learned-skills-web-mock', JSON.stringify(filtered))
+      return deletedCount
+    } catch (e) {
+      console.error("Failed to delete web mock skill:", e)
+      return 0
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<number>('delete_learned_skill', { name })
+}
+
+export async function getWorkspaceTree(path?: string | null): Promise<WorkspaceTreeEntry> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    return {
+      name: 'Workspace',
+      path: '.',
+      kind: 'directory',
+      children: [
+        { name: 'src', path: 'src', kind: 'directory', children: [] },
+        { name: 'package.json', path: 'package.json', kind: 'file', children: [] },
+      ],
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<WorkspaceTreeEntry>('get_workspace_tree', { path })
+}
+
+export async function createWorkspaceFile(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_file', { path })
+}
+
+export async function createWorkspaceFolder(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_folder', { path })
+}
+
+export async function deleteWorkspaceItem(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('delete_workspace_item', { path })
+}
+
+export async function selectWorkspaceDirectory(): Promise<string | null> {
+  if (typeof window === 'undefined' || !isTauriRuntime()) {
+    return null
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  const selected = await invoke<string | null>('select_workspace_directory')
+  return selected
+}
+
 export async function readClipboardImage(): Promise<string | null> {
   if (typeof window === 'undefined' || !isTauriRuntime()) {
+
     return null
   }
   const { invoke } = await import('@tauri-apps/api/core')
@@ -1188,3 +1229,40 @@ export async function readClipboardImage(): Promise<string | null> {
     return null
   }
 }
+
+// Enforce compile-time check against the shared platform interface
+const _apiCheck: MintPlatformApi = {
+  getRuntimeStatus,
+  detectSystemTools,
+  sendChatMessage,
+  streamChatMessage,
+  getTtsUrls,
+  cancelChatMessage,
+  getRecentInteractions,
+  saveSystemInteraction,
+  saveInteractionAgentActivity,
+  listChatSessions,
+  deleteChatSession,
+  renameChatSession,
+  getProfileValue,
+  setProfileValue,
+  listLearnedSkills,
+  addLearnedSkill,
+  deleteLearnedSkill,
+  clearChatHistory,
+  listSavedPictures,
+  generateImages,
+  getImageGenProviders,
+  setDefaultImageProvider,
+  getWorkspaceTree,
+  createWorkspaceFile,
+  createWorkspaceFolder,
+  deleteWorkspaceItem,
+  selectWorkspaceDirectory,
+  submitToolApproval,
+  proposeCodeEdits,
+  applyCodeEdits,
+  listen,
+  readClipboardImage,
+}
+

package/src-tauri/src/desktop.rs

@@ -201,28 +201,30 @@ pub fn capture_screen() -> Result<String, String> {
 }
 
 pub fn read_clipboard_image() -> Result<String, String> {
-    let output = Command::new("wl-paste").args(&["-t", "image/png"]).output();
+    let output = Command::new("wl-paste").args(["-t", "image/png"]).output();
 
-    if let Ok(out) = output {
-        if out.status.success() && !out.stdout.is_empty() {
-            return Ok(format!(
-                "data:image/png;base64,{}",
-                STANDARD.encode(&out.stdout)
-            ));
-        }
+    if let Ok(out) = output
+        && out.status.success()
+        && !out.stdout.is_empty()
+    {
+        return Ok(format!(
+            "data:image/png;base64,{}",
+            STANDARD.encode(&out.stdout)
+        ));
     }
 
     let output = Command::new("xclip")
-        .args(&["-selection", "clipboard", "-t", "image/png", "-o"])
+        .args(["-selection", "clipboard", "-t", "image/png", "-o"])
         .output();
 
-    if let Ok(out) = output {
-        if out.status.success() && !out.stdout.is_empty() {
-            return Ok(format!(
-                "data:image/png;base64,{}",
-                STANDARD.encode(&out.stdout)
-            ));
-        }
+    if let Ok(out) = output
+        && out.status.success()
+        && !out.stdout.is_empty()
+    {
+        return Ok(format!(
+            "data:image/png;base64,{}",
+            STANDARD.encode(&out.stdout)
+        ));
     }
 
     Err("No image found in clipboard".into())

package/src-tauri/src/discord_rpc.rs

@@ -14,7 +14,7 @@ pub fn set_activity(config: &MintConfig, instruction: &str) -> Result<String, St
         .filter(|value| !value.trim().is_empty())
         .ok_or("missing config value 'discordApplicationId'")?;
     let input: Value = serde_json::from_str(instruction).unwrap_or_else(|_| {
-        json!({ "details": instruction.trim().is_empty().then_some("Using Mint Assistant").unwrap_or(instruction) })
+        json!({ "details": if instruction.trim().is_empty() { "Using Mint Assistant" } else { instruction } })
     });
     let activity = json!({
         "details": input["details"].as_str().unwrap_or("Using Mint Assistant"),

package/src-tauri/src/lib.rs

@@ -119,11 +119,7 @@ fn get_runtime_status() -> Result<RuntimeStatus, String> {
             .display()
             .to_string(),
         active_provider: config.ai_provider.clone(),
-        available_providers: config
-            .available_providers()
-            .into_iter()
-            .map(str::to_owned)
-            .collect(),
+        available_providers: config.available_providers(),
         integrations: integration_status(&config),
     })
 }
@@ -322,10 +318,38 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
         clean_request.message = request.message.strip_prefix("/chat ").unwrap().to_owned();
+        let config_clone = config.clone();
+        let chat_id_str = request.chat_id.clone().unwrap_or_default();
 
-        let (response, _) = orchestrate_chat_with_fallback(&config, &clean_request)
-            .await
-            .map_err(|error| error.to_string())?;
+        let join_handle = tokio::spawn(async move {
+            orchestrate_chat_with_fallback(&config_clone, &clean_request).await
+        });
+
+        let abort_handle = join_handle.abort_handle();
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS
+                .lock()
+                .unwrap()
+                .insert(chat_id_str.clone(), abort_handle);
+        }
+
+        let res = join_handle.await;
+
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS
+                .lock()
+                .unwrap()
+                .remove(&chat_id_str);
+        }
+
+        let (response, _) = match res {
+            Ok(Ok(val)) => val,
+            Ok(Err(e)) => return Err(e.to_string()),
+            Err(e) if e.is_cancelled() => {
+                return Err("Chat execution cancelled by user".to_string());
+            }
+            Err(e) => return Err(format!("Task panicked: {}", e)),
+        };
         return Ok(response);
     }
 
@@ -363,19 +387,53 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
     let progress_cb = |_| {};
     let on_chunk = |_| {};
 
-    let res = orchestrate_agent_loop(
-        &config,
-        &request.message,
-        &root,
-        request.image_data_uri.clone(),
-        request.chat_id.as_deref(),
-        fast_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
-    )
-    .await
-    .map_err(|e| e.to_string())?;
+    let chat_id_str = request.chat_id.clone().unwrap_or_default();
+    let config_clone = config.clone();
+    let message_clone = request.message.clone();
+    let root_clone = root.clone();
+    let image_data_uri_clone = request.image_data_uri.clone();
+    let chat_id_clone = request.chat_id.clone();
+    let agent_id_clone = request.agent_id.clone();
+
+    let join_handle = tokio::spawn(async move {
+        orchestrate_agent_loop(
+            &config_clone,
+            &message_clone,
+            &root_clone,
+            image_data_uri_clone,
+            chat_id_clone.as_deref(),
+            agent_id_clone.as_deref(),
+            fast_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        )
+        .await
+    });
+
+    let abort_handle = join_handle.abort_handle();
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS
+            .lock()
+            .unwrap()
+            .insert(chat_id_str.clone(), abort_handle);
+    }
+
+    let res = join_handle.await;
+
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS
+            .lock()
+            .unwrap()
+            .remove(&chat_id_str);
+    }
+
+    let res = match res {
+        Ok(Ok(val)) => val,
+        Ok(Err(e)) => return Err(e.to_string()),
+        Err(e) if e.is_cancelled() => return Err("Agent execution cancelled by user".to_string()),
+        Err(e) => return Err(format!("Task panicked: {}", e)),
+    };
 
     Ok(ChatResponse {
         provider: res.provider,
@@ -397,13 +455,42 @@ async fn stream_chat_message(
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
         clean_request.message = request.message.strip_prefix("/chat ").unwrap().to_owned();
+        let config_clone = config.clone();
+        let on_event_clone = on_event.clone();
+        let chat_id_str = request.chat_id.clone().unwrap_or_default();
 
-        let (response, _) =
-            orchestrate_chat_stream_with_fallback(&config, &clean_request, |chunk| {
-                let _ = on_event.send(DesktopStreamEvent::Chunk { chunk });
+        let join_handle = tokio::spawn(async move {
+            orchestrate_chat_stream_with_fallback(&config_clone, &clean_request, move |chunk| {
+                let _ = on_event_clone.send(DesktopStreamEvent::Chunk { chunk });
             })
             .await
-            .map_err(|error| error.to_string())?;
+        });
+
+        let abort_handle = join_handle.abort_handle();
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS
+                .lock()
+                .unwrap()
+                .insert(chat_id_str.clone(), abort_handle);
+        }
+
+        let res = join_handle.await;
+
+        if !chat_id_str.is_empty() {
+            mint_core::ACTIVE_AGENTS
+                .lock()
+                .unwrap()
+                .remove(&chat_id_str);
+        }
+
+        let (response, _) = match res {
+            Ok(Ok(val)) => val,
+            Ok(Err(e)) => return Err(e.to_string()),
+            Err(e) if e.is_cancelled() => {
+                return Err("Chat execution cancelled by user".to_string());
+            }
+            Err(e) => return Err(format!("Task panicked: {}", e)),
+        };
         return Ok(response);
     }
 
@@ -456,19 +543,53 @@ async fn stream_chat_message(
         }
     };
 
-    let res = orchestrate_agent_loop(
-        &config,
-        &request.message,
-        &root,
-        request.image_data_uri.clone(),
-        request.chat_id.as_deref(),
-        fast_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
-    )
-    .await
-    .map_err(|e| e.to_string())?;
+    let chat_id_str = request.chat_id.clone().unwrap_or_default();
+    let config_clone = config.clone();
+    let message_clone = request.message.clone();
+    let root_clone = root.clone();
+    let image_data_uri_clone = request.image_data_uri.clone();
+    let chat_id_clone = request.chat_id.clone();
+    let agent_id_clone = request.agent_id.clone();
+
+    let join_handle = tokio::spawn(async move {
+        orchestrate_agent_loop(
+            &config_clone,
+            &message_clone,
+            &root_clone,
+            image_data_uri_clone,
+            chat_id_clone.as_deref(),
+            agent_id_clone.as_deref(),
+            fast_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        )
+        .await
+    });
+
+    let abort_handle = join_handle.abort_handle();
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS
+            .lock()
+            .unwrap()
+            .insert(chat_id_str.clone(), abort_handle);
+    }
+
+    let res = join_handle.await;
+
+    if !chat_id_str.is_empty() {
+        mint_core::ACTIVE_AGENTS
+            .lock()
+            .unwrap()
+            .remove(&chat_id_str);
+    }
+
+    let res = match res {
+        Ok(Ok(val)) => val,
+        Ok(Err(e)) => return Err(e.to_string()),
+        Err(e) if e.is_cancelled() => return Err("Agent execution cancelled by user".to_string()),
+        Err(e) => return Err(format!("Task panicked: {}", e)),
+    };
 
     Ok(ChatResponse {
         provider: res.provider,
@@ -478,6 +599,12 @@ async fn stream_chat_message(
     })
 }
 
+#[tauri::command]
+async fn cancel_chat_message(chat_id: String) -> Result<(), String> {
+    mint_core::cancel_agent(&chat_id);
+    Ok(())
+}
+
 #[tauri::command]
 fn save_interaction_agent_activity(
     interaction_id: i64,
@@ -1054,8 +1181,8 @@ fn install_tray(app: &AppHandle) -> tauri::Result<()> {
 fn install_shortcuts(app: &AppHandle) -> tauri::Result<()> {
     let main_shortcut = Shortcut::new(Some(Modifiers::CONTROL | Modifiers::SHIFT), Code::Space);
     let spotlight_shortcut = Shortcut::new(Some(Modifiers::ALT), Code::Space);
-    let main_handler = main_shortcut.clone();
-    let spotlight_handler = spotlight_shortcut.clone();
+    let main_handler = main_shortcut;
+    let spotlight_handler = spotlight_shortcut;
     app.plugin(
         tauri_plugin_global_shortcut::Builder::new()
             .with_handler(move |app, shortcut, event| {
@@ -1123,6 +1250,7 @@ pub fn run() {
             inspect_shell_command,
             send_chat_message,
             stream_chat_message,
+            cancel_chat_message,
             submit_tool_approval,
             get_recent_interactions,
             save_interaction_agent_activity,

package/src-tauri/src/webhooks.rs

@@ -154,6 +154,7 @@ async fn answer(text: &str, system: &str) -> String {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         },
     )
     .await