@pheem49/mint 1.14.0 → 1.16.0

package/src/renderer/shared/utils/nativeRecordingSession.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+
+import { createNativeRecordingSession as create } from './nativeRecordingSession'
+
+function deferred() {
+  let resolve!: () => void
+  const promise = new Promise<void>(done => { resolve = done })
+  return { promise, resolve }
+}
+
+describe('native microphone recording lifecycle', () => {
+  it('discards a canceled recording even when device startup finishes later', async () => {
+    const ready = deferred(); const calls: string[] = []
+    const session = create({
+      startRecording: async () => { calls.push('start'); await ready.promise },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'should not send' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    const start = session.start()
+    const cancel = session.cancel()
+    ready.resolve()
+    expect(await start).toBe(false)
+    await cancel
+    expect(calls).toEqual(['start', 'discard'])
+  })
+  it('waits for startup before stopping, transcribes once, and permits another recording', async () => {
+    const ready = deferred(); const calls: string[] = []
+    const session = create({
+      startRecording: async () => { calls.push('start'); await ready.promise },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'Hello Mint' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    const start = session.start(); const stop = session.stop(); const duplicate = session.stop()
+    ready.resolve(); await start
+    expect(await stop).toBe('Hello Mint'); expect(await duplicate).toBe('Hello Mint')
+    expect(calls).toEqual(['start', 'transcribe'])
+    expect(await session.start()).toBe(true); await session.cancel()
+    expect(calls).toEqual(['start', 'transcribe', 'start', 'discard'])
+  })
+  it('does not transcribe or discard when opening the microphone is denied', async () => {
+    const calls: string[] = []
+    const session = create({
+      startRecording: async () => { throw new Error('Microphone denied') },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'wrong' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    await expect(session.start()).rejects.toThrow('Microphone denied')
+    await session.cancel(); expect(calls).toEqual([])
+  })
+  it('suppresses a transcript when canceled during transcription', async () => {
+    const ready = deferred()
+    const session = create({
+      startRecording: async () => {},
+      stopRecordingAndTranscribe: async () => { await ready.promise; return 'late transcript' },
+      cancelRecording: async () => { throw new Error('already stopped') }
+    })
+    await session.start(); const stop = session.stop(); await Promise.resolve()
+    const cancel = session.cancel(); ready.resolve()
+    expect(await stop).toBeNull(); await cancel
+  })
+})

package/src/renderer/shared/utils/nativeRecordingSession.ts

@@ -0,0 +1,46 @@
+export interface NativeRecordingBackend {
+  startRecording: () => Promise<void>
+  stopRecordingAndTranscribe: () => Promise<string>
+  cancelRecording: () => Promise<void>
+}
+
+/** One recorder lifecycle, including stop/cancel requests made during device startup. */
+export function createNativeRecordingSession(backend: NativeRecordingBackend) {
+  type Run = { phase: 'starting' | 'recording' | 'ending'; cancelled: boolean; ready: Promise<void>; result?: Promise<string | null> }
+  let run: Run | null = null
+
+  const start = async () => {
+    if (run) return false
+    const current: Run = { phase: 'starting', cancelled: false, ready: Promise.resolve() }
+    run = current
+    current.ready = backend.startRecording()
+    try {
+      await current.ready
+      if (current.phase !== 'starting') return false
+      current.phase = 'recording'
+      return true
+    } catch (error) {
+      if (run === current) run = null
+      throw error
+    }
+  }
+  const finish = (cancelled: boolean): Promise<string | null> => {
+    const current = run
+    if (!current) return Promise.resolve(null)
+    current.cancelled ||= cancelled
+    if (current.result) return current.result
+    current.phase = 'ending'
+    current.result = (async () => {
+      try {
+        try { await current.ready } catch { return null }
+        if (current.cancelled) { await backend.cancelRecording(); return null }
+        const text = await backend.stopRecordingAndTranscribe()
+        return current.cancelled ? null : text
+      } finally {
+        if (run === current) run = null
+      }
+    })()
+    return current.result
+  }
+  return { start, stop: () => finish(false), cancel: async () => { await finish(true) } }
+}

package/src/renderer/shared/utils/notificationSettings.test.ts

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest'
+import { shouldNotify } from './notificationSettings'
+
+it('preserves existing notifications when settings have not been saved yet', () => {
+  expect(shouldNotify(null, 'replies', 'os')).toBe(true)
+})
+it('applies master, category, and delivery switches independently', () => {
+  expect(shouldNotify({ enabled: false }, 'approvals', 'inApp')).toBe(false)
+  expect(shouldNotify({ replies: false }, 'replies', 'os')).toBe(false)
+  expect(shouldNotify({ replies: false }, 'approvals', 'os')).toBe(true)
+  expect(shouldNotify({ os: false }, 'system', 'os')).toBe(false)
+  expect(shouldNotify({ os: false }, 'system', 'inApp')).toBe(true)
+  expect(shouldNotify({ inApp: false }, 'system', 'inApp')).toBe(false)
+})

package/src/renderer/shared/utils/notificationSettings.ts

@@ -0,0 +1,23 @@
+export const DEFAULT_NOTIFICATION_SETTINGS = {
+  enabled: true, replies: true, approvals: true, system: true, os: true, inApp: true,
+}
+export type NotificationSettings = typeof DEFAULT_NOTIFICATION_SETTINGS
+export function readNotificationSettings(settings: unknown): NotificationSettings {
+  const data = settings && typeof settings === 'object' ? settings as Record<string, unknown> : {}
+  return Object.fromEntries(Object.entries(DEFAULT_NOTIFICATION_SETTINGS).map(([key, fallback]) =>
+    [key, typeof data[key] === 'boolean' ? data[key] : fallback])) as NotificationSettings
+}
+export function shouldNotify(settings: unknown, kind: 'replies' | 'approvals' | 'system', channel: 'os' | 'inApp'): boolean {
+  const preferences = readNotificationSettings(settings)
+  return preferences.enabled && preferences[kind] && preferences[channel]
+}
+
+export async function notificationPermission(request = false): Promise<NotificationPermission | 'unsupported'> {
+  if ((window as any).__TAURI_INTERNALS__) {
+    const api = await import('@tauri-apps/plugin-notification')
+    if (await api.isPermissionGranted()) return 'granted'
+    return request ? api.requestPermission() : 'default'
+  }
+  if (typeof Notification === 'undefined') return 'unsupported'
+  return request ? Notification.requestPermission() : Notification.permission
+}

package/src/renderer/shared/utils/notifications.test.ts

@@ -0,0 +1,51 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { sendBrowserNotification, clearBrowserNotifications, deliverNotification, receiveProactiveNotification } from './notifications'
+
+const shown: any[] = []
+class BrowserNotification {
+  static permission = 'granted'
+  close = vi.fn()
+  onclick?: () => void
+  onclose?: () => void
+  constructor(public title: string, public options: any) { shown.push(this) }
+}
+afterEach(() => { clearBrowserNotifications(); shown.length = 0; vi.unstubAllGlobals() })
+it('closes every outstanding notification when returning to Mint', async () => {
+  vi.stubGlobal('Notification', BrowserNotification)
+  await sendBrowserNotification('One')
+  await sendBrowserNotification('Two')
+  expect(shown).toHaveLength(2)
+  clearBrowserNotifications()
+  expect(shown.every(n => n.close.mock.calls.length === 1)).toBe(true)
+})
+it('opens the originating chat on click and dismisses that notification', async () => {
+  vi.stubGlobal('Notification', BrowserNotification)
+  const opened: string[] = []
+  await sendBrowserNotification('Done', 'chat-one', id => opened.push(id))
+  shown[0].onclick()
+  expect(opened).toEqual(['chat-one'])
+  expect(shown[0].close).toHaveBeenCalledOnce()
+})
+it('reports a rejected delivery without propagating it into the chat run', async () => {
+  const errors: string[] = []
+  await expect(deliverNotification(() => Promise.reject(new Error('No service')), message => errors.push(message))).resolves.toBeUndefined()
+  expect(errors).toEqual(['Could not send notification: No service'])
+})
+it('shows a background event in-app and sends its originating chat to the OS', async () => {
+  const notices: unknown[] = []
+  const deliveries: unknown[] = []
+  await receiveProactiveNotification({ message: 'Task completed', type: 'info', chatId: 'task-chat' }, true,
+    notice => notices.push(notice), async (body, chatId) => { deliveries.push({ body, chatId }) })
+  expect(notices).toEqual([{ message: 'Task completed', type: 'info', chatId: 'task-chat' }])
+  expect(deliveries).toEqual([{ body: 'Task completed', chatId: 'task-chat' }])
+})
+it('keeps foreground system events in-app and ignores malformed events', async () => {
+  const notices: unknown[] = []
+  const deliveries: unknown[] = []
+  const show = (notice: unknown) => { notices.push(notice) }
+  const send = async (body: string) => { deliveries.push(body) }
+  await receiveProactiveNotification({ message: 'Battery low', type: 'warning' }, false, show, send)
+  await receiveProactiveNotification({ message: '' }, true, show, send)
+  expect(notices).toEqual([{ message: 'Battery low', type: 'warning', chatId: undefined }])
+  expect(deliveries).toEqual([])
+})

package/src/renderer/shared/utils/notifications.ts

@@ -0,0 +1,54 @@
+const active = new Set<Notification>()
+let generation = 0
+
+export async function sendBrowserNotification(body: string, chatId?: string, openChat?: (id: string) => void): Promise<void> {
+  if (typeof Notification === 'undefined') throw new Error('Notifications are not supported here.')
+  const started = generation
+  let permission = Notification.permission
+  if (permission === 'default') permission = await Notification.requestPermission()
+  if (permission !== 'granted') throw new Error('Notification permission is not granted.')
+  // Returning to Mint while a permission prompt was pending cancels this delivery.
+  if (started !== generation) return
+  const notification = new Notification('Mint Agent', { body })
+  active.add(notification)
+  notification.onclose = () => active.delete(notification)
+  notification.onclick = () => {
+    notification.close()
+    active.delete(notification)
+    if (chatId) openChat?.(chatId)
+    else if (typeof window !== 'undefined') window.focus()
+  }
+}
+
+export function clearBrowserNotifications(): void {
+  generation++
+  for (const notification of active) notification.close()
+  active.clear()
+}
+
+export async function deliverNotification(send: () => unknown, report: (message: string) => void): Promise<void> {
+  try { await send() }
+  catch (error) { report('Could not send notification: ' + (error instanceof Error ? error.message : String(error))) }
+}
+
+export function openNotificationChat(chatId: string): void {
+  window.focus()
+  window.dispatchEvent(new CustomEvent('mint:notification-click', { detail: { chatId } }))
+}
+
+export type NotificationNotice = { message: string; chatId?: string; type?: string }
+export async function receiveProactiveNotification(
+  payload: unknown, background: boolean, show: (notice: NotificationNotice) => void,
+  send: (body: string, chatId?: string) => Promise<void>,
+): Promise<void> {
+  if (!payload || typeof payload !== 'object') return
+  const data = payload as Record<string, unknown>
+  if (typeof data.message !== 'string' || !data.message.trim()) return
+  const notice = {
+    message: data.message,
+    chatId: typeof data.chatId === 'string' ? data.chatId : undefined,
+    type: typeof data.type === 'string' ? data.type : undefined,
+  }
+  show(notice)
+  if (background) await send(notice.message, notice.chatId)
+}

package/src/renderer/shared/utils/pastedText.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { insertPastedText, pastedTextLabel } from './pastedText'
+
+describe('long clipboard text on Desktop and Web', () => {
+  it('collapses seven lines while retaining the complete submitted value', () => {
+    const result = insertPastedText('before selection after', 7, 16, 'a\rb\rc\rd\re\rf\rg')
+    expect(result.collapsed).toBe(true)
+    expect(result.value).toBe('before a\nb\nc\nd\ne\nf\ng after')
+    expect(result.text).toBe('a\nb\nc\nd\ne\nf\ng')
+    expect(result.caret).toBe(20)
+  })
+  it('keeps six lines inline and normalizes mixed clipboard line endings', () => {
+    const result = insertPastedText('', 0, 0, 'a\r\nb\rc\nd\ne\nf\r\n')
+    expect(result.collapsed).toBe(false)
+    expect(result.value).toBe('a\nb\nc\nd\ne\nf\n')
+  })
+  it('counts Unicode characters rather than UTF-16 units in the badge', () => {
+    expect(pastedTextLabel('🙂\na\nb\nc\nd\ne\nf')).toBe('[Pasted Content 13 chars]')
+  })
+})

package/src/renderer/shared/utils/pastedText.ts

@@ -0,0 +1,13 @@
+export function insertPastedText(value: string, start: number, end: number, text: string) {
+  const normalized = text.replace(/\r\n?/g, '\n')
+  return {
+    value: value.slice(0, start) + normalized + value.slice(end),
+    text: normalized,
+    caret: start + normalized.length,
+    collapsed: normalized.replace(/\n$/, '').split('\n').length > 6,
+  }
+}
+
+export function pastedTextLabel(text: string) {
+  return `[Pasted Content ${Array.from(text).length} chars]`
+}

package/src/renderer/shared/utils/progressCache.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import { parseFileChangesFromProgress } from '../agentProgress'
+import { activitiesFrom } from './agentActivity'
+import type { AgentProgress } from '../types'
+
+describe('immutable progress summaries', () => {
+  it('reuses file summaries while a turn has no new events', () => {
+    const progress: AgentProgress[] = []
+    expect(parseFileChangesFromProgress(progress)).toBe(parseFileChangesFromProgress(progress))
+  })
+  it('reuses activity views across unrelated UI updates', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'read_file', input: { path: '/a.ts' } } }]
+    expect(activitiesFrom(progress)).toBe(activitiesFrom(progress))
+  })
+  it('adds a completed file edit without changing the cached earlier snapshot', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'write_file', input: { path: '/a.ts', content: 'first\nsecond' } } }]
+    const before = parseFileChangesFromProgress(progress)
+    const next: AgentProgress[] = [...progress, { type: 'ToolEnd', data: { action: 'write_file', input: {}, result: 'ok' } }]
+    expect(parseFileChangesFromProgress(next)).toEqual([{ path: '/a.ts', created: true, additions: 2, deletions: 0, hunks: [{ oldText: '', newText: 'first\nsecond' }] }])
+    expect(before).toEqual([])
+    expect(parseFileChangesFromProgress(progress)).toBe(before)
+  })
+  it('updates activity when a new progress snapshot arrives', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'read_file', input: { path: '/a.ts' } } }]
+    const before = activitiesFrom(progress)
+    const next: AgentProgress[] = [...progress, { type: 'ToolEnd', data: { action: 'read_file', input: { path: '/a.ts' }, result: 'content' } }]
+    const after = activitiesFrom(next)
+    expect(after).not.toBe(before)
+    expect(before.items[0].state).not.toBe(after.items[0].state)
+    expect(activitiesFrom(progress)).toBe(before)
+  })
+})

package/src/renderer/shared/utils/providers.ts

@@ -7,6 +7,7 @@
 interface ProviderResponse {
   provider: string
   fallbackProvider?: string | null
+  fallbackReason?: string | null
 }
 
 export function badge(provider: string, model: string): string {
@@ -14,7 +15,9 @@ export function badge(provider: string, model: string): string {
 }
 
 export function providerLabel(provider: string): string {
-  switch (provider) {
+  if (!provider) return 'Primary provider'
+  const normalized = provider.startsWith('custom:') ? provider.replace(/^custom:/, '') : provider
+  switch (normalized.toLowerCase()) {
     case 'gemini':       return 'Gemini'
     case 'openai':       return 'OpenAI'
     case 'openrouter':   return 'OpenRouter'
@@ -23,7 +26,8 @@ export function providerLabel(provider: string): string {
     case 'huggingface':  return 'Hugging Face'
     case 'local_openai': return 'Local OpenAI'
     case 'ollama':       return 'Ollama'
-    default:             return provider || 'Primary provider'
+    case 'groq':         return 'Groq'
+    default:             return normalized.charAt(0).toUpperCase() + normalized.slice(1)
   }
 }
 
@@ -31,6 +35,7 @@ export function fallbackNotice(
   response: ProviderResponse | null | undefined,
 ): string {
   if (!response?.fallbackProvider) return ''
-  return `${providerLabel(response.fallbackProvider)} unavailable, fell back to ${providerLabel(response.provider)}.`
+  const reasonText = response.fallbackReason ? ` (${response.fallbackReason})` : ''
+  return `${providerLabel(response.fallbackProvider)} unavailable${reasonText}, fell back to ${providerLabel(response.provider)}.`
 }
 

package/src/renderer/shared/utils/screenCapture.ts

@@ -0,0 +1,43 @@
+/** Capture one frame from an explicitly user-approved screen share. */
+async function captureBrowserScreen(): Promise<string> {
+  if (!navigator.mediaDevices?.getDisplayMedia) {
+    throw new Error('Screen sharing is unavailable in this browser. Use a supported desktop browser or attach an image file.')
+  }
+
+  const stream = await navigator.mediaDevices.getDisplayMedia({ video: true, audio: false })
+  try {
+    await new Promise<void>((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve())))
+    const video = document.createElement('video')
+    video.srcObject = stream
+    video.muted = true
+    video.playsInline = true
+    await new Promise<void>((resolve, reject) => {
+      const timeout = window.setTimeout(() => reject(new Error('The screen share did not produce a frame. Please try again.')), 8000)
+      video.addEventListener('loadeddata', () => { window.clearTimeout(timeout); resolve() }, { once: true })
+      video.addEventListener('error', () => { window.clearTimeout(timeout); reject(new Error('Unable to read the shared screen.')) }, { once: true })
+      void video.play().catch((reason) => { window.clearTimeout(timeout); reject(reason) })
+    })
+    if (!video.videoWidth || !video.videoHeight) throw new Error('The selected screen has no image.')
+    const canvas = document.createElement('canvas')
+    canvas.width = video.videoWidth
+    canvas.height = video.videoHeight
+    const context = canvas.getContext('2d')
+    if (!context) throw new Error('Unable to prepare the screenshot.')
+    context.drawImage(video, 0, 0)
+    return canvas.toDataURL('image/png')
+  } finally {
+    stream.getTracks().forEach((track) => track.stop())
+  }
+}
+
+async function captureNativeWithoutMint(): Promise<string> {
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<string>('capture_chat_screen')
+}
+
+export async function captureScreenForChat(isDesktopApp: boolean): Promise<string> {
+  if (isDesktopApp && navigator.userAgent.toLowerCase().includes('linux')) {
+    return captureNativeWithoutMint()
+  }
+  return captureBrowserScreen()
+}

package/src/renderer/shared/utils/sessionSources.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+import { collectSessionSources } from './sessionSources'
+import type { AgentProgress } from '../types'
+import { createElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import SessionSources from '../components/SessionSources'
+
+const search = (url: string, title = 'Reference'): AgentProgress => ({ type: 'ToolEnd', data: { action: 'web_search', input: { query: 'example' }, result: `1. ${title}\nURL: ${url}\nA useful reference` } })
+describe('session sources', () => {
+  it('includes sent images and files alongside historical and live searches, deduplicating pages', () => {
+    const result = collectSessionSources({ attachments: [
+      { id: 1, interactionId: 3, name: 'photo.png', kind: 'image', mimeType: 'image/png', thumbnailDataUri: 'data:image/png;base64,aGVsbG8=' },
+      { id: 2, interactionId: 7, name: 'notes.pdf', kind: 'file', mimeType: 'application/pdf', thumbnailDataUri: null },
+    ], webSearchProgress: [search('https://example.com/docs')] }, [search('https://example.com/docs'), search('https://other.example/guide')])
+    expect(result.map(source => source.name)).toEqual(['photo.png', 'notes.pdf', 'Reference', 'Reference'])
+    expect(result[0]).toMatchObject({ kind: 'image', interactionId: 3, thumbnailDataUri: 'data:image/png;base64,aGVsbG8=' })
+    expect(result[1]).toMatchObject({ kind: 'file', detail: 'PDF' })
+    expect(result[2]).toMatchObject({ kind: 'web', url: 'https://example.com/docs', detail: 'example.com' })
+  })
+  it('does not turn non-web URLs or failed searches into source links', () => {
+    expect(collectSessionSources({ attachments: [], webSearchProgress: [search('javascript:alert(1)'), search('file:///etc/passwd')] })).toEqual([])
+    expect(collectSessionSources({ attachments: [], webSearchProgress: [search('https://example.com')] })).toHaveLength(1)
+  })
+  it('shows website favicons from the existing web-search source metadata', () => {
+    const sources = collectSessionSources({ attachments: [], webSearchProgress: [search('https://open.spotify.com/track/example?secret=private', 'Song')] })
+    expect(sources[0]).toMatchObject({ faviconUrl: 'https://www.google.com/s2/favicons?sz=32&domain=open.spotify.com' })
+    const html = renderToStaticMarkup(createElement(SessionSources, { sources, loading: false, error: '', onRetry: () => {}, onOpenLibrary: () => {} }))
+    expect(html).toContain('src="https://www.google.com/s2/favicons?sz=32&domain=open.spotify.com"')
+    expect(html).toContain('referrerPolicy="no-referrer"')
+  })
+})

package/src/renderer/shared/utils/sessionSources.ts

@@ -0,0 +1,34 @@
+import type { AgentProgress, ConversationSources } from '../types'
+import { parseWebSearchSources } from './agentActivity'
+
+export interface SessionSource {
+  id: string
+  kind: 'image' | 'file' | 'video' | 'web'
+  name: string
+  detail: string
+  interactionId?: number
+  thumbnailDataUri?: string
+  faviconUrl?: string
+  url?: string
+}
+
+export function collectSessionSources(persisted: ConversationSources, liveProgress: AgentProgress[] = []): SessionSource[] {
+  const attachments: SessionSource[] = persisted.attachments.map(attachment => ({
+    id: `attachment:${attachment.id}`, kind: attachment.kind, name: attachment.name,
+    detail: attachment.trashed ? 'In Trash · Restore in Library' : attachment.availability === 'missing' ? 'Original file missing' : attachment.kind === 'image' ? 'Image' : attachment.kind === 'video' ? 'Video' : (attachment.name.split('.').length > 1 ? attachment.name.split('.').at(-1)!.toUpperCase() : 'File'),
+    url: attachment.libraryItemId ? `/library?${new URLSearchParams({ item: attachment.libraryItemId, ...(attachment.trashed ? { trash: '1' } : {}) })}` : undefined,
+    interactionId: attachment.interactionId ?? undefined, thumbnailDataUri: attachment.thumbnailDataUri || undefined,
+  }))
+  const seen = new Set<string>()
+  const web: SessionSource[] = []
+  const progress = [...persisted.webSearchProgress, ...liveProgress].filter(event => event.type !== 'ToolEnd' || !event.data.status || event.data.status === 'success')
+  for (const source of parseWebSearchSources(progress)) {
+    const url = new URL(source.url)
+    if (!['http:', 'https:'].includes(url.protocol)) continue
+    url.hash = ''
+    if (seen.has(url.href)) continue
+    seen.add(url.href)
+    web.push({ id: `web:${url.href}`, kind: 'web', name: source.title || source.domain, detail: source.domain, url: url.href, faviconUrl: source.faviconUrl })
+  }
+  return [...attachments, ...web]
+}

package/src/renderer/shared/utils/slashCommandProcessor.ts

@@ -8,7 +8,7 @@
 
 export interface SlashCommandExecutionResult {
   handled: boolean
-  action?: 'open_image_picker' | 'paste_image' | 'generate_veo' | 'system_message'
+  action?: 'open_image_picker' | 'paste_image' | 'generate_veo' | 'system_message' | 'resume_session'
   payload?: any
   systemText?: string
 }
@@ -39,6 +39,9 @@ export function executeSlashCommand(input: string): SlashCommandExecutionResult
     case '/paste':
       return { handled: true, action: 'paste_image', payload: { prompt: rest } }
 
+    case '/resume':
+      return { handled: true, action: 'resume_session', payload: { query: rest } }
+
     case '/veo': {
       if (!rest) {
         return {
@@ -71,7 +74,7 @@ export function executeSlashCommand(input: string): SlashCommandExecutionResult
         handled: true,
         action: 'system_message',
         systemText:
-          '🧍 **Project Avatar** — the desktop app renders the live companion automatically. Use the CLI `/avatar link` to pair an external viewer.',
+          '🧍 **Project Avatar** — use the CLI `/avatar link` to pair a Project Avatar viewer. The separate Mint Companion app connects locally to Mint for Live2D.',
       }
 
     default:

package/src/renderer/shared/utils/sourceAttachments.ts

@@ -0,0 +1,28 @@
+import type { SourceAttachment } from '../types'
+import type { PromptOptions } from '../conversation/lifecycle'
+
+async function thumbnail(dataUri: string): Promise<string | null> {
+  try {
+    const image = new Image()
+    image.src = dataUri
+    await image.decode()
+    const ratio = Math.min(1, 160 / Math.max(image.naturalWidth, image.naturalHeight))
+    const canvas = document.createElement('canvas')
+    canvas.width = Math.max(1, Math.round(image.naturalWidth * ratio))
+    canvas.height = Math.max(1, Math.round(image.naturalHeight * ratio))
+    const context = canvas.getContext('2d')
+    if (!context) return null
+    context.drawImage(image, 0, 0, canvas.width, canvas.height)
+    return canvas.toDataURL('image/webp', .75)
+  } catch { return null }
+}
+
+export async function sourceAttachments(options: PromptOptions): Promise<SourceAttachment[]> {
+  const mime = (uri: string) => /^data:([^;,]+)/.exec(uri)?.[1] || 'application/octet-stream'
+  const images = await Promise.all((options.imageAttachments || []).map(async image => ({
+    name: image.name, kind: 'image' as const, mimeType: mime(image.dataUri), thumbnailDataUri: await thumbnail(image.dataUri),
+  })))
+  const videos = (options.videoAttachments || []).map(video => ({ name: video.name, kind: 'video' as const, mimeType: mime(video.dataUri), thumbnailDataUri: null }))
+  const document = options.documentAttachment
+  return [...images, ...videos, ...(document ? [{ name: document.filename, kind: 'file' as const, mimeType: mime(document.dataUri), thumbnailDataUri: null }] : [])]
+}