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