@pheem49/mint 1.14.0 → 1.16.0

package/src/renderer/src/tauri.ts

@@ -1,10 +1,10 @@
+import { createLibraryTransport } from '../shared/library/transport'
+import { createSourcesTransport } from '../shared/conversation/sourcesTransport'
 /** Returns true when running inside the Tauri webview (desktop app). */
 export const isTauriRuntime = (): boolean =>
   typeof window !== 'undefined' && Boolean((window as any).__TAURI_INTERNALS__)
 
-/** The last browser Notification shown by notifyAiResponse's fallback
- * (non-Tauri) branch, so clearAiNotifications can dismiss it. */
-let lastAiNotification: Notification | null = null
+import { sendBrowserNotification, clearBrowserNotifications, openNotificationChat } from '../shared/utils/notifications'
 
 /**
  * Page-relative: Tauri loads the bundled webview assets from relative paths
@@ -26,6 +26,7 @@ export const getLocalApiBase = (): string => {
 
 export * from '../shared/types'
 import type { MintPlatformApi } from '../shared/platform'
+import { createConversationTransport } from '../shared/conversation/transport'
 import type {
 
   RuntimeStatus,
@@ -34,12 +35,13 @@ import type {
   DocumentAttachment,
   AgentProgress,
   InteractionMemory,
+  ConversationSnapshot,
+  ConversationChanges,
   ChatSession,
   PictureEntry,
   ImageGenRequest,
   ImageGenProviders,
   ImageGenResponse,
-  WorkspaceTreeEntry,
   CodeEdit,
   CodeEditProposal,
   LearnedSkill,
@@ -48,14 +50,14 @@ import type {
   CronJobDraft,
   LinkedFolder,
   LinkedFolderDraft,
+  LinkedFolderNote,
+  LinkedFolderStatus,
   GitCheckpoint,
+  GitBranchInfo,
+  GitBranchChangeOutcome,
 } from '../shared/types'
 
 
-type DesktopStreamEvent =
-  | { type: 'chunk'; chunk: string }
-  | { type: 'progress'; progress: AgentProgress }
-
 export type { GeminiLiveEvent } from '../shared/utils/useGeminiLiveVoice'
 import type { GeminiLiveEvent } from '../shared/utils/useGeminiLiveVoice'
 
@@ -319,9 +321,9 @@ export async function fetchProviderModels(
   return invoke<string[]>('fetch_provider_models', { provider, apiKey, baseUrl })
 }
 
-/** Fetch the live model list for image `provider` from its API.
- *  Returns a dynamic list on success, falling back to static presets on any
- *  network or auth error. Results are cached for 1 hour on the Rust side. */
+/** Fetch image model choices from the shared Rust catalog.
+ *  Discovered models precede missing presets; blank overrides use the saved key.
+ *  Provider discovery is cached for 1 hour on the Rust side. */
 export async function fetchImageProviderModels(
   provider: string,
   apiKey: string = '',
@@ -330,9 +332,9 @@ export async function fetchImageProviderModels(
   return invoke<string[]>('fetch_image_provider_models', { provider, apiKey: apiKey || '' })
 }
 
-/** Fetch the live model list for video `provider` from its API.
- *  Returns a dynamic list on success, falling back to static presets on any
- *  network or auth error. Results are cached for 1 hour on the Rust side. */
+/** Fetch video model choices from the shared Rust catalog.
+ *  Discovered models precede missing presets; blank overrides use the saved key.
+ *  Provider discovery is cached for 1 hour on the Rust side. */
 export async function fetchVideoProviderModels(
   provider: string,
   apiKey: string = '',
@@ -341,10 +343,9 @@ export async function fetchVideoProviderModels(
   return invoke<string[]>('fetch_video_provider_models', { provider, apiKey: apiKey || '' })
 }
 
-/** Fetch the list of Gemini Live–capable models (BidiGenerateContent / native-audio)
- *  from the Gemini API. Returns a dynamic list on success; falls back to an empty
- *  array so the hook can use its static GEMINI_LIVE_MODELS preset instead.
- *  Results are cached for 1 hour on the Rust side. */
+/** Fetch Gemini Live model choices from the shared Rust catalog.
+ *  Discovered models precede missing presets; blank overrides use the saved key.
+ *  Provider discovery is cached for 1 hour on the Rust side. */
 export async function fetchGeminiLiveModels(apiKey: string): Promise<string[]> {
   const { invoke } = await import('@tauri-apps/api/core')
   return invoke<string[]>('fetch_gemini_live_models', { apiKey: apiKey || '' })
@@ -378,157 +379,12 @@ export async function uploadFile(file: File): Promise<string> {
   return url;
 }
 
-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,
-  planMode?: boolean,
-): Promise<ChatResponse> {
-  const outgoingMessage = withImagePlaceholder(message, imageDataUri, videoDataUri)
-  if (!isTauriRuntime()) {
-    const API_BASE = getLocalApiBase();
-    try {
-      const res = await authFetch(`${API_BASE}/chat`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, agentId })
-      });
-      const data = await res.json().catch(() => null);
-      if (!res.ok) {
-        return {
-          provider: 'error',
-          model: 'error',
-          text: data?.text || data?.message || data?.status || `Local API returned HTTP ${res.status}`,
-        };
-      }
-      if (!data || typeof data.text !== 'string') {
-        return { provider: 'error', model: 'error', text: 'Local API returned an invalid chat response.' };
-      }
-      return data;
-    } catch (e) {
-      console.error("Failed to send chat message to local server:", e);
-      return { provider: 'error', model: 'error', text: `Failed to connect to Local API Server: ${e}` };
-    }
-  }
-  const { invoke } = await import('@tauri-apps/api/core')
-  const response = await invoke<ChatResponse>('send_chat_message', {
-    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, agentId, planMode: planMode ?? false },
-  })
-  if (imageDataUri) {
-    await invoke('save_pictures', {
-      images: imageDataUri.split(' '),
-      source: 'chat',
-      message: outgoingMessage,
-    })
-  }
-  if (videoDataUri) {
-    await invoke('save_pictures', {
-      images: videoDataUri.split(' '),
-      source: 'chat',
-      message: outgoingMessage,
-    })
-  }
-  return response
-}
-
-export async function streamChatMessage(
-  message: string,
-  onChunk: (chunk: string) => void,
-  imageDataUri?: string | null,
-  audioDataUri?: string | null,
-  videoDataUri?: string | null,
-  systemInstruction = '',
-  onProgress?: (progress: AgentProgress) => void,
-  documentAttachment?: DocumentAttachment | null,
-  workspacePath?: string | null,
-  chatId?: string | null,
-  agentId?: string | null,
-  planMode?: boolean,
-  pinnedMcpServer?: string | null,
-  // Only meaningful for the non-Tauri fallback branch below — the real
-  // Tauri branch gets approvals via the separate global
-  // `listen('tool-approval-requested', ...)` event instead, independent of
-  // this function, so it ignores this parameter entirely.
-  onApprovalRequested?: (payload: { token: string; approval: any }) => void,
-): Promise<ChatResponse> {
-  if (!isTauriRuntime()) {
-    const API_BASE = getLocalApiBase();
-    const outgoingMessage = withImagePlaceholder(message, imageDataUri, videoDataUri);
-    const res = await authFetch(`${API_BASE}/chat-stream`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, agentId, pinnedMcpServer })
-    });
-    if (!res.ok) {
-      const data = await res.json().catch(() => null);
-      throw new Error(data?.text || data?.message || `HTTP ${res.status}`);
-    }
-    const reader = res.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body reader");
-    }
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let finalResponse: ChatResponse | null = null;
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const event = JSON.parse(line);
-          if (event.type === 'chunk') {
-            onChunk(event.chunk);
-          } else if (event.type === 'progress') {
-            onProgress?.(event.progress);
-          } else if (event.type === 'done') {
-            finalResponse = event.response;
-          } else if (event.type === 'approval-requested') {
-            onApprovalRequested?.({ token: event.token, approval: event.approval });
-          }
-        } catch (e) {
-          console.error("Failed to parse stream line:", line, e);
-        }
-      }
-    }
-    if (finalResponse) return finalResponse;
-    throw new Error("Stream closed without a final response");
-  }
-  const { invoke, Channel } = await import('@tauri-apps/api/core')
-  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, videoDataUri, documentAttachment, workspacePath, agentId, planMode: planMode ?? false, pinnedMcpServer },
-    onEvent,
-  })
-  if (imageDataUri) {
-    await invoke('save_pictures', {
-      images: imageDataUri.split(' '),
-      source: 'chat',
-      message: outgoingMessage,
-    })
-  }
-  if (videoDataUri) {
-    await invoke('save_pictures', {
-      images: videoDataUri.split(' '),
-      source: 'chat',
-      message: outgoingMessage,
-    })
-  }
-  return response
-}
+export const { sendChatMessage, streamChatMessage } = createConversationTransport({
+  isNative: isTauriRuntime,
+  apiBase: getLocalApiBase,
+  fetch: authFetch,
+  ownerToken: getStoredAuthToken,
+})
 
 /**
  * Starts a Gemini Live realtime voice session (beta, desktop-only). Returns a session id
@@ -587,21 +443,14 @@ export async function stopMicRecordingAndTranscribe(): Promise<string> {
   return invoke<string>('stop_mic_recording_and_transcribe')
 }
 
-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
+/** Stops native recording and discards audio without contacting a transcription provider. */
+export async function cancelMicRecording(): Promise<void> {
+  if (!isTauriRuntime()) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('cancel_mic_recording')
 }
 
+
 export async function getTtsUrls(text: string): Promise<TtsUrl[]> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return []
   const { invoke } = await import('@tauri-apps/api/core')
@@ -640,6 +489,29 @@ export async function getRecentInteractions(limit = 50, chatId?: string | null,
   return invoke<InteractionMemory[]>('get_recent_interactions', { limit, chatId, workspacePath })
 }
 
+export async function getConversationSnapshot(chatId: string, beforeId?: number | null, limit = 50): Promise<ConversationSnapshot> {
+  if (!isTauriRuntime()) {
+    const params = new URLSearchParams({ chatId, limit: String(limit) })
+    if (beforeId != null) params.set('beforeId', String(beforeId))
+    const response = await authFetch(`${getLocalApiBase()}/conversation-snapshot?${params}`)
+    if (!response.ok) throw new Error(`Conversation snapshot failed: ${response.status}`)
+    return response.json()
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<ConversationSnapshot>('get_conversation_snapshot', { chatId, beforeId, limit })
+}
+
+export async function getConversationChanges(chatId: string, after: number, limit = 100): Promise<ConversationChanges> {
+  if (!isTauriRuntime()) {
+    const params = new URLSearchParams({ chatId, after: String(after), limit: String(limit) })
+    const response = await authFetch(`${getLocalApiBase()}/conversation-changes?${params}`)
+    if (!response.ok) throw new Error(`Conversation changes failed: ${response.status}`)
+    return response.json()
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<ConversationChanges>('get_conversation_changes', { chatId, after, limit })
+}
+
 export async function saveSystemInteraction(
   chatId: string,
   userText: string,
@@ -705,6 +577,23 @@ export async function listChatSessions(): Promise<ChatSession[]> {
   return invoke<ChatSession[]>('list_chat_sessions')
 }
 
+export async function updateChatSessionWorkspace(chatId: string, workspacePath: string | null): Promise<void> {
+  if (!isTauriRuntime()) {
+    const res = await authFetch(`${getLocalApiBase()}/chat-sessions/workspace`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chatId, workspacePath })
+    })
+    if (!res.ok) {
+      const data = await res.json().catch(() => null)
+      throw new Error(data?.error || `Could not save conversation workspace (HTTP ${res.status})`)
+    }
+    return
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('update_chat_session_workspace', { chatId, workspacePath })
+}
+
 export async function deleteChatSession(chatId: string): Promise<number> {
   if (!isTauriRuntime()) {
     const API_BASE = getLocalApiBase();
@@ -783,7 +672,10 @@ export async function listLearnedSkills(workspacePath?: string): Promise<Learned
   if (typeof window === 'undefined' || !isTauriRuntime()) {
     try {
       const API_BASE = getLocalApiBase()
-      const res = await authFetch(`${API_BASE}/learned-skills`)
+      const params = new URLSearchParams()
+      if (workspacePath?.trim()) params.set('workspacePath', workspacePath)
+      const suffix = params.size ? `?${params.toString()}` : ''
+      const res = await authFetch(`${API_BASE}/learned-skills${suffix}`)
       if (res.ok) {
         return await res.json()
       }
@@ -903,19 +795,20 @@ export async function deleteSubagent(sourcePath: string): Promise<void> {
 
 export async function runSlashCommand(
   input: string,
-  cwd?: string | null
+  cwd?: string | null,
+  chatId?: string | null
 ): Promise<import('../shared/platform').SlashResponse> {
   if (!isTauriRuntime()) {
     const res = await authFetch(`${getLocalApiBase()}/slash`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ input, cwd: cwd ?? null })
+      body: JSON.stringify({ input, cwd: cwd ?? null, chat_id: chatId ?? null, ownerToken: getStoredAuthToken() })
     })
     if (!res.ok) return { kind: 'not_handled' }
     return res.json()
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('run_slash_command', { input, cwd: cwd ?? null })
+  return invoke('run_slash_command', { input, cwd: cwd ?? null, chatId: chatId ?? null, ownerToken: getStoredAuthToken() })
 }
 
 export async function listCronJobs(): Promise<CronJob[]> {
@@ -972,7 +865,7 @@ export async function setCronJobEnabled(id: string, enabled: boolean): Promise<C
 export async function listLinkedFolders(): Promise<Record<string, LinkedFolder>> {
   if (!isTauriRuntime()) {
     const res = await authFetch(`${getLocalApiBase()}/linked-folders`)
-    if (!res.ok) return {}
+    if (!res.ok) throw new Error('Failed to load linked folders')
     return res.json()
   }
   const { invoke } = await import('@tauri-apps/api/core')
@@ -1008,6 +901,52 @@ export async function removeLinkedFolder(name: string): Promise<void> {
   await invoke('remove_linked_folder', { name })
 }
 
+export async function linkedFolderStatus(name: string): Promise<LinkedFolderStatus> {
+  if (!isTauriRuntime()) {
+    const res = await authFetch(`${getLocalApiBase()}/linked-folders/${encodeURIComponent(name)}/status`)
+    if (!res.ok) throw new Error('Failed to load folder status')
+    return res.json()
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('linked_folder_status', { name })
+}
+
+export async function refreshLinkedFolder(name: string): Promise<LinkedFolderStatus> {
+  if (!isTauriRuntime()) {
+    const res = await authFetch(`${getLocalApiBase()}/linked-folders/${encodeURIComponent(name)}/refresh`, { method: 'POST' })
+    if (!res.ok) throw new Error('Failed to refresh folder')
+    return res.json()
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('refresh_linked_folder', { name })
+}
+
+export async function listLinkedFolderNotes(name: string): Promise<LinkedFolderNote[]> {
+  if (!isTauriRuntime()) {
+    const res = await authFetch(`${getLocalApiBase()}/linked-folders/${encodeURIComponent(name)}/notes`)
+    if (!res.ok) throw new Error('Failed to load notes')
+    return res.json()
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('list_linked_folder_notes', { name })
+}
+
+export async function readLinkedFolderNote(name: string, id: string): Promise<string> {
+  if (!isTauriRuntime()) {
+    const res = await authFetch(`${getLocalApiBase()}/linked-folders/${encodeURIComponent(name)}/notes/${encodeURIComponent(id)}`)
+    if (!res.ok) throw new Error('Failed to read note')
+    return (await res.json()).content
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('read_linked_folder_note', { name, id })
+}
+
+export async function openLinkedFolderNote(name: string, id: string): Promise<void> {
+  if (!isTauriRuntime()) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('open_linked_folder_note', { name, id })
+}
+
 export async function clearChatHistory(chatId?: string | null): Promise<number> {
   if (!isTauriRuntime()) {
     const API_BASE = getLocalApiBase();
@@ -1167,38 +1106,107 @@ export async function setDefaultImageProvider(provider: string): Promise<boolean
 
 
 
-export async function getWorkspaceTree(path?: string | null): Promise<WorkspaceTreeEntry> {
+export async function getWorkspaceSnapshot(operation: import('../shared/types').WorkspaceOperation): Promise<import('../shared/types').WorkspaceSnapshot> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     return {
-      name: 'Workspace',
-      path: '.',
-      kind: 'directory',
-      children: [
-        { name: 'src', path: 'src', kind: 'directory', children: [] },
-        { name: 'package.json', path: 'package.json', kind: 'file', children: [] },
-      ],
+      path: operation.root, revision: operation.revision,
+      git: { isRepository: false, currentBranch: null, detachedHead: null, branches: [], remoteBranches: [], isDirty: false },
+      tree: { name: 'Workspace', path: '.', kind: 'directory', children: [] },
     }
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke<WorkspaceTreeEntry>('get_workspace_tree', { path })
+  return invoke('get_workspace_snapshot', { operation })
 }
 
-export async function createWorkspaceFile(path: string): Promise<void> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+export async function getWorkspaceGitDiff(workspacePath: string): Promise<import('../shared/types').FileChange[]> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    return []
+  }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('create_workspace_file', { path })
+  return invoke<import('../shared/types').FileChange[]>('get_workspace_git_diff', { workspacePath })
 }
 
-export async function createWorkspaceFolder(path: string): Promise<void> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+export async function getGitBranchInfo(workspacePath: string): Promise<GitBranchInfo> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    return { isRepository: false, currentBranch: null, detachedHead: null, branches: [], remoteBranches: [], isDirty: false }
+  }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('create_workspace_folder', { path })
+  return invoke<GitBranchInfo>('get_git_branch_info', { workspacePath })
 }
 
-export async function deleteWorkspaceItem(path: string): Promise<void> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+export async function switchGitBranch(
+  workspacePath: string,
+  branch: string,
+  confirmedDirtyWorkspace = false,
+): Promise<GitBranchChangeOutcome> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    throw new Error('Branch switching is only available in the desktop app.')
+  }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('delete_workspace_item', { path })
+  return invoke<GitBranchChangeOutcome>('switch_git_branch', { workspacePath, branch, confirmedDirtyWorkspace })
+}
+
+export async function createGitBranch(
+  workspacePath: string,
+  branch: string,
+  confirmedDirtyWorkspace = false,
+): Promise<GitBranchChangeOutcome> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    throw new Error('Branch creation is only available in the desktop app.')
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<GitBranchChangeOutcome>('create_git_branch', { workspacePath, branch, confirmedDirtyWorkspace })
+}
+
+export async function checkoutRemoteGitBranch(
+  workspacePath: string,
+  remoteBranch: string,
+  confirmedDirtyWorkspace = false,
+): Promise<GitBranchChangeOutcome> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    throw new Error('Remote branch checkout is only available in the desktop app.')
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<GitBranchChangeOutcome>('checkout_remote_git_branch', { workspacePath, remoteBranch, confirmedDirtyWorkspace })
+}
+
+export async function getGitGraph(workspacePath: string): Promise<string[]> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return []
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<string[]>('get_git_graph', { workspacePath })
+}
+
+export async function createWorkspaceFile(operation: import('../shared/types').WorkspaceOperation): Promise<import('../shared/types').WorkspaceSnapshot> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) throw new Error('Workspace files are only available in the desktop app.')
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_file', { operation })
+}
+
+export async function createWorkspaceFolder(operation: import('../shared/types').WorkspaceOperation): Promise<import('../shared/types').WorkspaceSnapshot> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) throw new Error('Workspace folders are only available in the desktop app.')
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_folder', { operation })
+}
+
+export async function deleteWorkspaceItem(operation: import('../shared/types').WorkspaceOperation): Promise<import('../shared/types').WorkspaceSnapshot> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) throw new Error('Workspace files are only available in the desktop app.')
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('delete_workspace_item', { operation })
+}
+
+export async function moveWorkspaceItem(operation: import('../shared/types').WorkspaceOperation, destination: string): Promise<import('../shared/types').WorkspaceSnapshot> {
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('move_workspace_item', { operation, destination })
+}
+
+export async function listWorkspaceHistory(root: string): Promise<import('../shared/types').WorkspaceHistoryEntry[]> {
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('list_workspace_history', { root })
+}
+
+export async function undoWorkspaceAction(root: string, revision: number, expectedId?: string): Promise<import('../shared/types').WorkspaceSnapshot> {
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('undo_workspace_action', { root, revision, expectedId })
 }
 
 export async function selectWorkspaceDirectory(): Promise<string | null> {
@@ -1349,16 +1357,13 @@ export function installTauriAdapters() {
 
     (window as any).widgetAPI = {
       onStateChange: () => {},
+      openChat: async () => {},
+      setVisible: async () => {},
+      startDragging: async () => {},
     };
 
     (window as any).screenPickerApi = {
-      onScreenshot: () => {},
-      sendSelection: () => {},
-      startContinuousTranslation: () => {},
-      stopContinuousTranslation: () => {},
-      onTranslationResult: () => {},
       closePicker: () => {},
-      setOverlayInteractable: () => {},
     };
 
     (window as any).api = {
@@ -1458,8 +1463,6 @@ export function installTauriAdapters() {
       },
       onSettingsChanged: () => {},
       startVision: () => {},
-      onVisionReady: async () => () => {},
-      captureSilentScreen: async () => '',
       getSmartContext: async () => {
         try {
           const res = await authFetch(`${API_BASE}/smart-context`);
@@ -1497,20 +1500,8 @@ export function installTauriAdapters() {
         }
       },
       onSpotlightToChat: async () => () => {},
-      notifyAiResponse: async (preview: string) => {
-        if (typeof Notification === 'undefined') return
-        let permission = Notification.permission
-        if (permission === 'default') {
-          permission = await Notification.requestPermission()
-        }
-        if (permission === 'granted') {
-          lastAiNotification = new Notification('Mint Agent', { body: preview })
-        }
-      },
-      clearAiNotifications: () => {
-        lastAiNotification?.close()
-        lastAiNotification = null
-      },
+      notifyAiResponse: (preview: string, chatId?: string) => sendBrowserNotification(preview, chatId, openNotificationChat),
+      clearAiNotifications: clearBrowserNotifications,
       getTtsUrls: async () => [],
       setAiState: () => {},
     };
@@ -1610,58 +1601,27 @@ export function installTauriAdapters() {
       const { listen } = await import('@tauri-apps/api/event')
       void listen<string>('widget-state', (event) => callback(event.payload))
     },
-  }
-
-  window.screenPickerApi = {
-    onScreenshot: async (callback) => {
+    openChat: async () => {
       const { invoke } = await import('@tauri-apps/api/core')
-      try {
-        const image = await captureSharedScreen()
-        callback(image)
-      } catch (reason) {
-        console.warn('Screen share capture failed, falling back to native capture:', reason)
-        void invoke<string>('capture_silent_screen').then(callback)
-      }
+      await invoke('open_window', { kind: 'main' })
     },
-    sendSelection: async (image) => {
+    setVisible: async (visible) => {
       const { invoke } = await import('@tauri-apps/api/core')
-      return void invoke('submit_screen_selection', { image })
-    },
-    startContinuousTranslation: (rect) => {
-      let translationTimer: ReturnType<typeof setInterval> | null = null
-      const translate = async () => {
-        const { invoke } = await import('@tauri-apps/api/core')
-        void invoke<string>('translate_capture_region', { rect })
-          .then((text) => window.dispatchEvent(new CustomEvent('mint-translation', { detail: text })))
-          .catch((reason) => {
-            window.dispatchEvent(new CustomEvent('mint-translation', { detail: String(reason) }))
-          })
-      }
-      translate()
-      translationTimer = setInterval(translate, 3000)
-      
-      // Clean up helper attached to window if needed
-      if ((window as any)._stopTranslate) (window as any)._stopTranslate()
-      ;(window as any)._stopTranslate = () => {
-        if (translationTimer) clearInterval(translationTimer)
-      }
+      const config = await invoke<Record<string, unknown>>('get_config')
+      await invoke('update_config', { config: { ...config, showDesktopWidget: visible } })
     },
-    stopContinuousTranslation: () => {
-      if ((window as any)._stopTranslate) {
-        (window as any)._stopTranslate()
-      }
-    },
-    onTranslationResult: (callback) => {
-      window.addEventListener('mint-translation', ((event: CustomEvent<string>) => {
-        callback(event.detail)
-      }) as EventListener)
+    startDragging: async () => {
+      const { getCurrentWindow } = await import('@tauri-apps/api/window')
+      await getCurrentWindow().startDragging()
     },
+  }
+
+  window.screenPickerApi = {
     closePicker: async () => {
       const { invoke } = await import('@tauri-apps/api/core')
       const { getCurrentWindow } = await import('@tauri-apps/api/window')
       return invoke('close_desktop_window', { label: getCurrentWindow().label })
     },
-    setOverlayInteractable: () => {},
   }
 
   window.api = {
@@ -1708,23 +1668,7 @@ export function installTauriAdapters() {
     onSettingsChanged: settingsChanged,
     startVision: async () => {
       const { invoke } = await import('@tauri-apps/api/core')
-      try {
-        const image = await captureSharedScreen()
-        window.localStorage.setItem('mint:pending-screen-capture', image)
-      } catch (reason) {
-        console.warn('Screen share capture failed before opening picker:', reason)
-        const image = await invoke<string>('capture_silent_screen')
-        window.localStorage.setItem('mint:pending-screen-capture', image)
-      }
-      return invoke('start_screen_capture')
-    },
-    onVisionReady: async (callback) => {
-      const { listen } = await import('@tauri-apps/api/event')
-      return listen<string>('vision-ready', (event) => callback(event.payload))
-    },
-    captureSilentScreen: async () => {
-      const { invoke } = await import('@tauri-apps/api/core')
-      return invoke('capture_silent_screen')
+      return invoke('start_live_translate')
     },
     getSmartContext: async () => {
       const { invoke } = await import('@tauri-apps/api/core')
@@ -1752,19 +1696,10 @@ export function installTauriAdapters() {
       const { listen } = await import('@tauri-apps/api/event')
       return listen<string>('spotlight-to-chat', (event) => callback(event.payload))
     },
-    notifyAiResponse: async (preview) => {
-      const { isPermissionGranted, requestPermission, sendNotification } = await import('@tauri-apps/plugin-notification')
-      let granted = await isPermissionGranted()
-      if (!granted) {
-        granted = (await requestPermission()) === 'granted'
-      }
-      if (granted) {
-        sendNotification({ title: 'Mint Agent', body: preview })
-      }
+    notifyAiResponse: async (preview, chatId) => {
+      const { invoke } = await import('@tauri-apps/api/core')
+      await invoke('send_mint_notification', { body: preview, chatId: chatId ?? null })
     },
-    // The plugin has no reliable cross-platform way to dismiss an
-    // already-shown OS notification from JS — best-effort no-op; there's
-    // simply nothing stale left for the next unfocused reply to build on.
     clearAiNotifications: () => {},
     getTtsUrls: async (text) => {
       const { invoke } = await import('@tauri-apps/api/core')
@@ -1777,46 +1712,6 @@ export function installTauriAdapters() {
   }
 }
 
-async function captureSharedScreen(): Promise<string> {
-  // On Linux (especially under Wayland/WebKitGTK), getDisplayMedia often returns a black screen
-  // or fails silently. Bypass it to force fallback to native screenshot commands.
-  if (navigator.userAgent.toLowerCase().includes('linux')) {
-    throw new Error('Linux detected, bypassing getDisplayMedia to use native screenshot tools')
-  }
-
-  if (!navigator.mediaDevices?.getDisplayMedia) {
-    throw new Error('getDisplayMedia is not available')
-  }
-
-  const stream = await navigator.mediaDevices.getDisplayMedia({
-    video: true,
-    audio: false,
-  })
-  try {
-    const video = document.createElement('video')
-    video.srcObject = stream
-    video.muted = true
-    await video.play()
-    await new Promise<void>((resolve) => {
-      if (video.videoWidth > 0 && video.videoHeight > 0) {
-        resolve()
-      } else {
-        video.onloadedmetadata = () => resolve()
-      }
-    })
-
-    const canvas = document.createElement('canvas')
-    canvas.width = video.videoWidth || window.screen.width
-    canvas.height = video.videoHeight || window.screen.height
-    const context = canvas.getContext('2d')
-    if (!context) throw new Error('Unable to create screen capture canvas')
-    context.drawImage(video, 0, 0, canvas.width, canvas.height)
-    return canvas.toDataURL('image/png')
-  } finally {
-    stream.getTracks().forEach((track) => track.stop())
-  }
-}
-
 export async function readClipboardImage(): Promise<string | null> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     return null
@@ -2242,8 +2137,28 @@ export const readWorkspaceFile = async (path: string, workspacePath?: string): P
   return invoke('read_workspace_file', { path, workspacePath })
 }
 
+export async function modsOperation(operation: import('../shared/mods').ModOperation): Promise<import('../shared/mods').ModResponse> {
+  if (isTauriRuntime()) {
+    const { invoke } = await import('@tauri-apps/api/core')
+    return invoke('mods_operation', { operation })
+  }
+  const res = await authFetch(`${getLocalApiBase()}/mods`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(operation) })
+  const value = await res.json()
+  if (!res.ok) throw new Error(value.error || 'Mod operation failed')
+  return value
+}
+
+export const { listLibrary, getLibraryItem, setLibraryTrashed, removeLibraryItem, readLibraryFile } = createLibraryTransport({ isNative: isTauriRuntime, apiBase: getLocalApiBase, fetch: authFetch })
+
+export const { getConversationSources, saveSourceAttachments } = createSourcesTransport({ isNative: isTauriRuntime, apiBase: getLocalApiBase, fetch: authFetch })
+
 // Enforce compile-time check against the shared platform interface
 const _apiCheck: MintPlatformApi = {
+  listLibrary, getLibraryItem, setLibraryTrashed, removeLibraryItem, readLibraryFile,
+  getConversationSources, saveSourceAttachments,
+  modsOperation,
+  readMcpArtifact,
+  listBackgroundJobs, getBackgroundJob, stopBackgroundJob, deleteBackgroundJob,
   runSlashCommand,
   authRegister,
   authLogin,
@@ -2258,9 +2173,12 @@ const _apiCheck: MintPlatformApi = {
   getTtsUrls,
   cancelChatMessage,
   getRecentInteractions,
+  getConversationSnapshot,
+  getConversationChanges,
   saveSystemInteraction,
   saveInteractionAgentActivity,
   listChatSessions,
+  updateChatSessionWorkspace,
   deleteChatSession,
   renameChatSession,
   getProfileValue,
@@ -2277,10 +2195,20 @@ const _apiCheck: MintPlatformApi = {
   generateImages,
   getImageGenProviders,
   setDefaultImageProvider,
-  getWorkspaceTree,
+  getWorkspaceSnapshot,
+  getWorkspaceGitDiff,
+  getGitBranchInfo,
+  switchGitBranch,
+  createGitBranch,
+  checkoutRemoteGitBranch,
+  getGitGraph,
   createWorkspaceFile,
   createWorkspaceFolder,
   deleteWorkspaceItem,
+  moveWorkspaceItem,
+  listWorkspaceHistory,
+  startHtmlPreview,
+  undoWorkspaceAction,
   selectWorkspaceDirectory,
   selectLinkedFolderPath,
   submitToolApproval,
@@ -2294,3 +2222,38 @@ const _apiCheck: MintPlatformApi = {
   readWorkspaceFile,
   testMcpConnection,
 }
+
+
+async function backgroundRequest<T>(path: string, method = 'GET'): Promise<T> {
+  const response = await authFetch(`${getLocalApiBase()}/background-jobs${path}`, { method })
+  const value = await response.json()
+  if (!response.ok) throw new Error(`${response.status}: ${value.message || 'Background terminal request failed'}`)
+  return value as T
+}
+export async function listBackgroundJobs(workspace?: string): Promise<import('../shared/types').BackgroundJob[]> {
+  if (isTauriRuntime()) { const { invoke } = await import('@tauri-apps/api/core'); return invoke<import('../shared/types').BackgroundJob[]>('list_background_jobs', { workspace: workspace || null, ownerToken: getStoredAuthToken() }) }
+  const value = await backgroundRequest<{jobs: import('../shared/types').BackgroundJob[]}>(workspace ? `?workspace=${encodeURIComponent(workspace)}` : '')
+  return value.jobs
+}
+export async function getBackgroundJob(id: string) { if (isTauriRuntime()) { const { invoke } = await import('@tauri-apps/api/core'); return invoke<import('../shared/types').BackgroundJobOutput>('get_background_job', { id, ownerToken: getStoredAuthToken() }) } return backgroundRequest<import('../shared/types').BackgroundJobOutput>(`/${encodeURIComponent(id)}`) }
+export async function stopBackgroundJob(id: string) { if (isTauriRuntime()) { const { invoke } = await import('@tauri-apps/api/core'); return invoke<import('../shared/types').BackgroundJob>('stop_background_job', { id, ownerToken: getStoredAuthToken() }) } return backgroundRequest<import('../shared/types').BackgroundJob>(`/${encodeURIComponent(id)}/stop`, 'POST') }
+export async function deleteBackgroundJob(id: string) { if (isTauriRuntime()) { const { invoke } = await import('@tauri-apps/api/core'); await invoke('remove_background_job', { id, ownerToken: getStoredAuthToken() }); return } await backgroundRequest<{deleted: boolean}>(`/${encodeURIComponent(id)}`, 'DELETE') }
+
+export async function startHtmlPreview(root: string, relativePath: string, mintBrowser = false): Promise<{url: string; jobId: string}> {
+  if (isTauriRuntime()) { const { invoke } = await import('@tauri-apps/api/core'); return invoke('start_html_preview', { root, relativePath, ownerToken: getStoredAuthToken() }) }
+  const response = await authFetch(`${getLocalApiBase()}/html-preview`, { method: 'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify({root, relativePath, mintBrowser}) })
+  const value = await response.json()
+  if (!response.ok) throw new Error(value.message || 'Could not start HTML preview')
+  return value
+}
+
+/** Loads artifacts by ID; no server-provided filesystem path is accepted. */
+export async function readMcpArtifact(id: string): Promise<string> {
+  if (isTauriRuntime()) {
+    const { invoke } = await import('@tauri-apps/api/core')
+    return invoke<string>('read_mcp_artifact', { id })
+  }
+  const response = await authFetch(`${getLocalApiBase()}/mcp-artifacts/${encodeURIComponent(id)}`)
+  if (!response.ok) throw new Error('Artifact unavailable')
+  return URL.createObjectURL(await response.blob())
+}