@pheem49/mint 1.6.3 → 1.7.0

package/src/renderer/src/tauri.ts

@@ -42,6 +42,7 @@ export interface InteractionMemory {
   model: string
   fallbackProvider?: string | null
   createdAt: string
+  agentActivity?: AgentProgress[] | null
 }
 
 export interface ChatSession {
@@ -65,6 +66,29 @@ export interface PictureEntry {
   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 WorkspaceTreeEntry {
   name: string
   path: string
@@ -258,6 +282,30 @@ export async function getRecentInteractions(limit = 50, chatId?: string | null):
   return invoke<InteractionMemory[]>('get_recent_interactions', { limit, chatId })
 }
 
+export async function saveInteractionAgentActivity(
+  interactionId: number,
+  activity: AgentProgress[],
+): Promise<void> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    const API_BASE = "http://localhost:3000/api";
+    try {
+      const res = await fetch(`${API_BASE}/interactions/agent-activity`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ interactionId, activity }),
+      });
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status}`);
+      }
+    } catch (error) {
+      console.error('Failed to persist agent activity:', error);
+    }
+    return;
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('save_interaction_agent_activity', { interactionId, activity })
+}
+
 export async function listChatSessions(): Promise<ChatSession[]> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     const API_BASE = "http://localhost:3000/api";
@@ -394,6 +442,106 @@ export async function listSavedPictures(): Promise<PictureEntry[]> {
   return invoke<PictureEntry[]>('list_pictures')
 }
 
+export async function generateImages(
+  request: ImageGenRequest
+): Promise<ImageGenResponse> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    const API_BASE = 'http://localhost:3000/api'
+    const res = await fetch(`${API_BASE}/image-generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        prompt: request.prompt,
+        negativePrompt: request.negativePrompt,
+        aspectRatio: request.aspectRatio ?? '1:1',
+        numImages: request.numImages ?? 1,
+        model: request.model,
+        provider: request.provider,
+      }),
+    })
+    if (!res.ok) {
+      const err = await res.json().catch(() => null)
+      throw new Error(err?.error || `Image generation failed: HTTP ${res.status}`)
+    }
+    const data = await res.json()
+    // Normalize image URLs for web mode
+    const images: PictureEntry[] = Array.isArray(data.images)
+      ? data.images.map((pic: PictureEntry) => {
+          const pictureUrl = pic.url ? `http://localhost:3000${pic.url}` : pic.url
+          return { ...pic, url: pictureUrl, thumbnailUrl: pictureUrl }
+        })
+      : []
+    return { ...data, images }
+  }
+  // Desktop / Tauri mode
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<ImageGenResponse>('generate_images', { request })
+}
+
+/** Fetch which image-generation providers are currently configured on the backend. */
+export async function getImageGenProviders(): Promise<ImageGenProviders> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    const API_BASE = 'http://localhost:3000/api'
+    try {
+      const res = await fetch(`${API_BASE}/image-gen/providers`)
+      if (res.ok) return await res.json()
+    } catch (_) { /* ignore */ }
+    return { active: 'nanobanana', available: ['nanobanana'] }
+  }
+  // Desktop / Tauri: read config to know which keys are set
+  try {
+    const { invoke } = await import('@tauri-apps/api/core')
+    const config = await invoke<Record<string, string>>('get_config')
+    const available: string[] = []
+    if (config.api_key)            available.push('nanobanana')
+    if (config.openai_api_key)     available.push('dalle')
+    if (config.stability_api_key)  available.push('stability')
+    if (config.ideogram_api_key)   available.push('ideogram')
+    if (config.replicate_api_key)  available.push('replicate')
+    if (available.length === 0)    available.push('nanobanana')
+    const active = available.includes(config.image_gen_provider)
+      ? config.image_gen_provider
+      : available[0]
+    return { active, available }
+  } catch (_) {
+    return { active: 'nanobanana', available: ['nanobanana'] }
+  }
+}
+
+/** Updates the default image generation provider in the configuration. */
+export async function setDefaultImageProvider(provider: string): Promise<boolean> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
+    const API_BASE = "http://localhost:3000/api";
+    try {
+      const getRes = await fetch(`${API_BASE}/config`)
+      if (!getRes.ok) return false
+      const config = await getRes.json()
+      config.image_gen_provider = provider
+      const saveRes = await fetch(`${API_BASE}/config`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(config)
+      })
+      return saveRes.ok
+    } catch (_) {
+      return false
+    }
+  }
+
+  // Desktop / Tauri
+  try {
+    const { invoke } = await import('@tauri-apps/api/core')
+    const config = await invoke<any>('get_config')
+    config.image_gen_provider = provider
+    await invoke('update_config', { config })
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+
+
 export async function getWorkspaceTree(path?: string | null): Promise<WorkspaceTreeEntry> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     return {

package/src/renderer/src-web/App.tsx

@@ -19,7 +19,22 @@ export default function App() {
 
   let content = <MintDashboard />
 
-  if (route.startsWith('/settings')) content = <SettingsWindow />
+  // For web, show settings as a centered modal overlay instead of a full-page route
+  if (route.startsWith('/settings')) {
+    content = (
+      <>
+        <MintDashboard />
+        <div
+          className="settings-modal-overlay"
+          onClick={() => window.settingsApi?.closeSettings?.()}
+        >
+          <div className="settings-modal" onClick={(e) => e.stopPropagation()}>
+            <SettingsWindow />
+          </div>
+        </div>
+      </>
+    )
+  }
 
   return <Suspense fallback={null}>{content}</Suspense>
 }

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

@@ -0,0 +1,39 @@
+import type { AgentProgress, InteractionMemory } from './tauri'
+
+export function thoughtsFrom(progress: AgentProgress[]): string[] {
+  return progress
+    .filter((event) => event.type === 'Thought')
+    .map((event) => (event as Extract<AgentProgress, { type: 'Thought' }>).data.thought)
+    .filter(Boolean)
+}
+
+export function trimAgentProgress(progress: AgentProgress[], maxNonThought = 20): AgentProgress[] {
+  if (progress.length === 0) return progress
+  const keptNonThought = new Set(
+    progress.filter((event) => event.type !== 'Thought').slice(-maxNonThought),
+  )
+  return progress.filter((event) => event.type === 'Thought' || keptNonThought.has(event))
+}
+
+export function hasAgentToolActivity(progress: AgentProgress[]): boolean {
+  return progress.some((event) => event.type === 'ToolStart' || event.type === 'ToolEnd')
+}
+
+export function mergeActivitySnapshots(
+  current: Record<string, AgentProgress[]>,
+  interactions: InteractionMemory[],
+): Record<string, AgentProgress[]> {
+  const merged = { ...current }
+  for (const interaction of interactions) {
+    const key = String(interaction.id)
+    if (interaction.agentActivity?.length && !merged[key]) {
+      merged[key] = interaction.agentActivity
+    }
+  }
+  return merged
+}
+
+export function parseAgentActivity(value: unknown): AgentProgress[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  return value as AgentProgress[]
+}