@pheem49/mint 1.15.0 → 1.17.0

package/src/renderer/shared/conversation/transport.ts

@@ -0,0 +1,201 @@
+import type { MintPlatformApi } from '../platform'
+import type { AgentProgress, ChatResponse, DocumentAttachment, AttachmentMetadata } from '../types'
+
+type ConversationOperations = Pick<MintPlatformApi, 'sendChatMessage' | 'streamChatMessage'>
+type TransportEnvironment = {
+  isNative(): boolean
+  apiBase(): string
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+  ownerToken(): string | null
+}
+
+type StreamEvent =
+  | { type: 'started'; interactionId: number }
+  | { type: 'chunk'; chunk: string }
+  | { type: 'progress'; progress: AgentProgress }
+  | { type: 'approval-requested'; token: string; approval: any }
+  | { type: 'done'; response: ChatResponse }
+
+type StreamCallbacks = {
+  onChunk(chunk: string): void
+  onProgress?: (progress: AgentProgress) => void
+  onApprovalRequested?: (payload: { token: string; approval: any }) => void
+  onTurnStarted?: (interactionId: number) => void
+}
+
+function deliverEvent(event: StreamEvent, callbacks: StreamCallbacks): ChatResponse | undefined {
+  switch (event?.type) {
+    case 'chunk': callbacks.onChunk(event.chunk); break
+    case 'started': callbacks.onTurnStarted?.(event.interactionId); break
+    case 'progress': callbacks.onProgress?.(event.progress); break
+    case 'approval-requested': callbacks.onApprovalRequested?.({ token: event.token, approval: event.approval }); break
+    case 'done': return event.response
+  }
+}
+
+async function readStream(response: Response, callbacks: StreamCallbacks): Promise<ChatResponse> {
+  const reader = response.body?.getReader()
+  if (!reader) throw new Error('No response body reader')
+  const decoder = new TextDecoder()
+  let buffer = ''
+  let finalResponse: ChatResponse | undefined
+  const consumeLine = (line: string) => {
+    if (!line.trim()) return
+    let event: StreamEvent
+    try {
+      event = JSON.parse(line)
+    } catch (error) {
+      console.error('Failed to parse stream line:', line, error)
+      return
+    }
+    // Consumer failures are transport failures, not malformed JSON.
+    const result = deliverEvent(event, callbacks)
+    if (result) finalResponse = result
+  }
+  try {
+    while (true) {
+      const { value, done } = await reader.read()
+      buffer += done ? decoder.decode() : decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+      for (const line of lines) consumeLine(line)
+      if (done) {
+        consumeLine(buffer)
+        break
+      }
+    }
+    if (finalResponse) return finalResponse
+    throw new Error('Stream closed without a final response')
+  } catch (error) {
+    await reader.cancel(error).catch(() => {})
+    throw error
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+function withMediaPlaceholders(message: string, imageDataUri?: string | null, videoDataUri?: string | null) {
+  for (const [kind, uris] of [['Image', imageDataUri], ['Video', videoDataUri]] as const) {
+    if (uris && !message.includes(`[${kind} #1]`)) {
+      const markers = uris.split(/\s+/).filter(Boolean).map((_, index) => `[${kind} #${index + 1}]`).join(' ')
+      if (markers) message = `${message} ${markers}`
+    }
+  }
+  return message
+}
+
+const MAX_REQUEST_BYTES = 32 * 1024 * 1024
+const REQUEST_LIMIT_ERROR = 'Attachments exceed the 32 MiB request limit. Send fewer files at once.'
+
+function utf8ByteLength(value?: string | null): number {
+  if (!value) return 0
+  if (value.length > MAX_REQUEST_BYTES) return value.length
+  if (value.startsWith('data:') && value.includes(';base64,')) return value.length
+  let bytes = value.length
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code >= 0x80) {
+      if (code <= 0x7ff) bytes += 1
+      else if (code >= 0xd800 && code <= 0xdbff) {
+        bytes += 2
+        i++
+      } else {
+        bytes += 2
+      }
+    }
+  }
+  return bytes
+}
+
+/** Shared wire contract; adapters supply runtime detection, address and authentication. */
+export function createConversationTransport(environment: TransportEnvironment): ConversationOperations {
+  const requestBody = (message: string, imageDataUri?: string | null, audioDataUri?: string | null,
+    videoDataUri?: string | null, systemInstruction = '', documentAttachment?: DocumentAttachment | null,
+    workspacePath?: string | null, chatId?: string | null, agentId?: string | null, planMode = false,
+    pinnedMcpServer?: string | null, attachmentMetadata?: AttachmentMetadata) => ({
+    ...(attachmentMetadata ? { attachmentMetadata } : {}),
+    message: withMediaPlaceholders(message, imageDataUri, videoDataUri), systemInstruction,
+    imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, chatId, agentId, planMode, pinnedMcpServer,
+  })
+
+  const assertWithinLimit = (request: ReturnType<typeof requestBody>) => {
+    const metadataBytes = request.attachmentMetadata
+      ? utf8ByteLength(request.attachmentMetadata.requestId)
+        + (request.attachmentMetadata.imageNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+        + (request.attachmentMetadata.videoNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+      : 0
+    const totalBytes = 256
+      + metadataBytes
+      + utf8ByteLength(request.message)
+      + utf8ByteLength(request.systemInstruction)
+      + utf8ByteLength(request.imageDataUri)
+      + utf8ByteLength(request.audioDataUri)
+      + utf8ByteLength(request.videoDataUri)
+      + utf8ByteLength(request.documentAttachment?.filename)
+      + utf8ByteLength(request.documentAttachment?.dataUri)
+      + utf8ByteLength(request.workspacePath)
+      + utf8ByteLength(request.chatId)
+      + utf8ByteLength(request.agentId)
+      + utf8ByteLength(request.pinnedMcpServer)
+    if (totalBytes > MAX_REQUEST_BYTES) throw new Error(REQUEST_LIMIT_ERROR)
+  }
+  const post = (route: string, request: ReturnType<typeof requestBody>) => {
+    assertWithinLimit(request)
+    return environment.fetch(`${environment.apiBase()}/${route}`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(request),
+    })
+  }
+
+
+  return {
+    async sendChatMessage(message, imageDataUri, audioDataUri, videoDataUri, documentAttachment,
+      workspacePath, chatId, agentId, planMode, attachmentMetadata) {
+      const request = requestBody(message, imageDataUri, audioDataUri, videoDataUri, '', documentAttachment,
+        workspacePath, chatId, agentId, planMode, undefined, attachmentMetadata)
+      if (!environment.isNative()) {
+        try {
+          const response = await post('chat', request)
+          const data = await response.json().catch(() => null)
+          if (!response.ok) return { provider: 'error', model: 'error',
+            text: data?.text || data?.message || data?.status || `Local API returned HTTP ${response.status}` }
+          if (!data || typeof data.text !== 'string') return {
+            provider: 'error', model: 'error', text: 'Local API returned an invalid chat response.',
+          }
+          return data
+        } catch (error) {
+          console.error('Failed to send chat message to local server:', error)
+          return { provider: 'error', model: 'error', text: `Failed to connect to Local API Server: ${error}` }
+        }
+      }
+      assertWithinLimit(request)
+      const { invoke } = await import('@tauri-apps/api/core')
+      const response = await invoke<ChatResponse>('send_chat_message', { ownerToken: environment.ownerToken(), request, ...(attachmentMetadata ? { attachmentMetadata } : {}) })
+      return response
+    },
+
+    async streamChatMessage(message, onChunk, imageDataUri, audioDataUri, videoDataUri, systemInstruction,
+      onProgress, documentAttachment, workspacePath, chatId, agentId, planMode, pinnedMcpServer,
+      onApprovalRequested, onTurnStarted, attachmentMetadata) {
+      const request = requestBody(message, imageDataUri, audioDataUri, videoDataUri, systemInstruction,
+        documentAttachment, workspacePath, chatId, agentId, planMode, pinnedMcpServer, attachmentMetadata)
+      const callbacks = { onChunk, onProgress, onApprovalRequested, onTurnStarted }
+      if (!environment.isNative()) {
+        const response = await post('chat-stream', request)
+        if (!response.ok) {
+          const data = await response.json().catch(() => null)
+          throw new Error(data?.text || data?.message || `HTTP ${response.status}`)
+        }
+        return readStream(response, callbacks)
+      }
+      assertWithinLimit(request)
+      const { invoke, Channel } = await import('@tauri-apps/api/core')
+      const onEvent = new Channel<StreamEvent>()
+      onEvent.onmessage = event => { deliverEvent(event, callbacks) }
+      // Native approvals arrive via the global tool-approval-requested event bus.
+      const response = await invoke<ChatResponse>('stream_chat_message', {
+        ownerToken: environment.ownerToken(), request, onEvent, ...(attachmentMetadata ? { attachmentMetadata } : {}),
+      })
+      return response
+    },
+  }
+}

package/src/renderer/shared/conversation/useConversationCoordinator.ts

@@ -1,102 +1,90 @@
-import { useEffect, useMemo, useReducer, useRef } from 'react'
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react'
 import type { ConversationState } from './coordinator'
-import { initialConversationState, transitionConversation } from './coordinator'
-import type { AgentProgress, ChatResponse } from '../types'
+import { createConversationLifecycle, type ConversationEffects, type ConversationTransport } from './lifecycle'
+import { conversationPlatform } from '../platform'
 
-interface CoordinatorOptions {
+interface CoordinatorOptions extends ConversationEffects {
   conversationId: string
   draftKeyPrefix: string
   workspaceStorageKey: string
+  historyVisible: boolean
 }
 
+/** React adapter: persistence and browser signals enter the same lifecycle tests use. */
 export function useConversationCoordinator(
   initial: Partial<ConversationState>,
   options: CoordinatorOptions,
+  transport: ConversationTransport = conversationPlatform,
 ) {
-  const [conversation, dispatch] = useReducer(transitionConversation, initial, initialConversationState)
-  const actions = useMemo(() => ({
-    compose: (message: string) => dispatch({ type: 'compose', message }),
-    selectWorkspace: (path: string) => dispatch({ type: 'workspace_selected', path }),
-    attachImage: (image: ConversationState['imageAttachments'][number]) => dispatch({ type: 'image_attached', image }),
-    removeImage: (index: number) => dispatch({ type: 'image_removed', index }),
-    attachVideo: (video: ConversationState['videoAttachments'][number]) => dispatch({ type: 'video_attached', video }),
-    removeVideo: (index: number) => dispatch({ type: 'video_removed', index }),
-    attachDocument: (document: ConversationState['documentAttachment']) => dispatch({ type: 'document_attached', document }),
-    startRun: (message: string, imageCount = 0, videoCount = 0) => dispatch({
-      type: 'run_started', message, imageCount, videoCount,
-    }),
-    receiveChunk: (chunk: string) => dispatch({ type: 'chunk_received', chunk }),
-    receiveProgress: (progress: AgentProgress[]) => dispatch({ type: 'progress_received', progress }),
-    clearProgress: () => dispatch({ type: 'progress_cleared' }),
-    clearStream: () => dispatch({ type: 'stream_cleared' }),
-    requestApproval: (approval: unknown) => dispatch({ type: 'approval_requested', approval }),
-    finishRun: () => dispatch({ type: 'run_finished' }),
-    cancelRun: () => dispatch({ type: 'run_cancelled' }),
-    clearComposer: () => dispatch({ type: 'composer_cleared' }),
-    switchSession: (draft = '') => dispatch({ type: 'session_switched', draft }),
-    executeStream: async (
-      execute: (onChunk: (chunk: string) => void) => Promise<ChatResponse>,
-      shouldApplyResponse: () => boolean = () => true,
-    ) => {
-      // Keep provider streaming internal and reveal only the authoritative
-      // completed response. This avoids partial Markdown/card layouts and
-      // keeps Desktop and Web behavior aligned with the CLI.
-      const response = await execute(() => {})
-      if (shouldApplyResponse()) {
-        dispatch({ type: 'chunk_received', chunk: response.text })
-        dispatch({ type: 'response_received', response })
-      }
-      return response
+  const latest = useRef(options)
+  latest.current = options
+  const [actions] = useState(() => createConversationLifecycle(options.conversationId, initial, transport, {
+    onError: error => latest.current.onError?.(error),
+    onApproval: (approval, chatId) => latest.current.onApproval?.(approval, chatId),
+    onReply: (response, chatId) => latest.current.onReply?.(response, chatId),
+    onActivityPersisted: id => latest.current.onActivityPersisted?.(id),
+    onRunCompleted: () => latest.current.onRunCompleted?.(),
+    onVisibleRunCompleted: chatId => latest.current.onVisibleRunCompleted?.(chatId),
+  }, {
+    read: id => window.localStorage.getItem(`${latest.current.draftKeyPrefix}${id}`) || '',
+    write: (id, text) => {
+      const key = `${latest.current.draftKeyPrefix}${id}`
+      if (text) window.localStorage.setItem(key, text)
+      else window.localStorage.removeItem(key)
     },
-    executeApproval: async (execute: () => Promise<void>) => {
-      try {
-        await execute()
-      } finally {
-        dispatch({ type: 'approval_resolved' })
+  }))
+  const dashboardSnapshotRef = useRef<ReturnType<typeof actions.getSnapshot> | null>(null)
+  const getDashboardSnapshot = () => {
+    const next = actions.getSnapshot()
+    const prev = dashboardSnapshotRef.current
+    if (prev && prev !== next) {
+      let onlyMessageChanged = prev.message !== next.message
+      if (onlyMessageChanged) {
+        for (const key of Object.keys(next) as Array<keyof typeof next>) {
+          if (key !== 'message' && prev[key] !== next[key]) {
+            onlyMessageChanged = false
+            break
+          }
+        }
       }
-    },
-    executeCancellation: async (execute: () => Promise<void>) => {
-      try {
-        await execute()
-      } finally {
-        dispatch({ type: 'run_cancelled' })
+      if (onlyMessageChanged) {
+        return prev
       }
-    },
-  }), [])
-
-  const loadedConversationRef = useRef(options.conversationId)
-  useEffect(() => {
-    if (loadedConversationRef.current === options.conversationId) return
-    loadedConversationRef.current = options.conversationId
-    let draft = ''
-    try {
-      draft = window.localStorage.getItem(`${options.draftKeyPrefix}${options.conversationId}`) || ''
-    } catch {
-      // Draft persistence is best-effort in private browsing modes.
     }
-    actions.switchSession(draft)
-  }, [actions, options.conversationId, options.draftKeyPrefix])
+    dashboardSnapshotRef.current = next
+    return next
+  }
+
+  const conversation = useSyncExternalStore(actions.subscribe, getDashboardSnapshot, getDashboardSnapshot)
+
+  useEffect(() => actions.watch({ window, document }, options.historyVisible),
+    [actions, options.historyVisible, conversation.conversationId])
 
   useEffect(() => {
-    const timer = window.setTimeout(() => {
-      try {
-        const key = `${options.draftKeyPrefix}${options.conversationId}`
-        if (conversation.message) window.localStorage.setItem(key, conversation.message)
-        else window.localStorage.removeItem(key)
-      } catch {
-        // Draft persistence is best-effort in private browsing modes.
-      }
-    }, 300)
-    return () => window.clearTimeout(timer)
-  }, [conversation.message, options.conversationId, options.draftKeyPrefix])
+    let timer: number | undefined
+    const unsubscribe = actions.subscribe(() => {
+      const snap = actions.getSnapshot()
+      if (timer !== undefined) window.clearTimeout(timer)
+      timer = window.setTimeout(() => {
+        try {
+          const key = `${latest.current.draftKeyPrefix}${snap.conversationId}`
+          if (snap.message) window.localStorage.setItem(key, snap.message)
+          else window.localStorage.removeItem(key)
+        } catch {
+          // Draft persistence is best-effort in private browsing modes.
+        }
+      }, 300)
+    })
+    return () => {
+      unsubscribe()
+      if (timer !== undefined) window.clearTimeout(timer)
+    }
+  }, [actions])
 
   useEffect(() => {
     try {
-      if (conversation.workspacePath) {
-        window.localStorage.setItem(options.workspaceStorageKey, conversation.workspacePath)
-      } else {
-        window.localStorage.removeItem(options.workspaceStorageKey)
-      }
+      if (conversation.workspacePath) window.localStorage.setItem(options.workspaceStorageKey, conversation.workspacePath)
+      else window.localStorage.removeItem(options.workspaceStorageKey)
     } catch {
       // Workspace persistence is best-effort in private browsing modes.
     }

package/src/renderer/shared/css/agent-observability.css

@@ -5,13 +5,13 @@
 
 /* --- Run Summary Dashboard --- */
 .run-summary-card {
-  border-radius: var(--radius-lg, 10px);
+  border-radius: var(--radius-lg, 12px);
   border: 1px solid var(--border-light, rgba(255, 255, 255, 0.08));
   background: color-mix(in srgb, var(--surface-bg, #252527) 80%, transparent);
   backdrop-filter: var(--glass-blur, blur(12px));
   -webkit-backdrop-filter: var(--glass-blur, blur(12px));
-  padding: 12px 14px;
-  margin-bottom: 10px;
+  padding: 12px;
+  margin-bottom: 0;
   color: var(--text-main, #e8e8ea);
   min-width: 0;
   max-width: 100%;
@@ -23,11 +23,10 @@
   align-items: center;
   justify-content: space-between;
   border-bottom: 1px solid var(--border, rgba(255, 255, 255, 0.08));
-  padding-bottom: 8px;
+  padding-bottom: 10px;
   margin-bottom: 10px;
-  gap: 8px;
+  gap: 10px;
   min-width: 0;
-  flex-wrap: wrap;
 }
 
 .run-summary-title,
@@ -36,19 +35,48 @@
   max-width: 100%;
 }
 
-.run-summary-title span {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.run-summary-title {
+  display: flex;
+  align-items: center;
+  flex: 1 1 auto;
+  gap: 9px;
+  color: var(--text-main, #e8e8ea);
 }
+.run-summary-title > svg { flex: 0 0 auto; color: var(--accent, #10b981); }
+.run-summary-heading { display: grid; gap: 2px; min-width: 0; }
+.run-summary-heading strong { font-size: 0.8rem; font-weight: 650; line-height: 1.25; }
+.run-summary-heading small { overflow: hidden; color: var(--text-muted); font-family: var(--font-mono, ui-monospace, monospace); font-size: 0.65rem; font-weight: 400; text-overflow: ellipsis; white-space: nowrap; }
 
-.run-summary-title {
+.run-summary-actions {
   display: flex;
   align-items: center;
   gap: 8px;
-  font-size: 0.82rem;
-  font-weight: 600;
+  flex-shrink: 0;
+}
+
+.run-summary-export-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 2px 7px;
+  border-radius: var(--radius-sm, 6px);
+  font-size: 0.70rem;
+  font-weight: 500;
+  color: var(--text-muted, #8f8f94);
+  background: var(--surface-bg, rgba(255, 255, 255, 0.05));
+  border: 1px solid var(--border, rgba(255, 255, 255, 0.1));
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+.run-summary-export-btn:hover {
   color: var(--text-main, #e8e8ea);
+  background: var(--surface-hover, rgba(255, 255, 255, 0.1));
+  border-color: var(--border-light, rgba(255, 255, 255, 0.2));
+}
+
+.run-summary-export-btn:active {
+  transform: scale(0.97);
 }
 
 .run-summary-badge {
@@ -59,38 +87,40 @@
   border-radius: var(--radius-full, 999px);
   font-size: 0.72rem;
   font-weight: 600;
+  white-space: nowrap;
 }
 
 .run-summary-badge.success {
-  background: color-mix(in srgb, var(--status-speaking, #22c55e) 15%, transparent);
-  color: var(--status-speaking, #22c55e);
-  border: 1px solid color-mix(in srgb, var(--status-speaking, #22c55e) 35%, transparent);
+  background: var(--status-success-bg);
+  color: var(--status-success-fg);
+  border: 1px solid var(--status-success-border);
 }
 
 .run-summary-badge.rollback {
-  background: color-mix(in srgb, #f59e0b 15%, transparent);
-  color: #f59e0b;
-  border: 1px solid color-mix(in srgb, #f59e0b 35%, transparent);
+  background: var(--status-warning-bg);
+  color: var(--status-warning-fg);
+  border: 1px solid var(--status-warning-border);
 }
 
 .run-summary-badge.failure {
-  background: color-mix(in srgb, var(--status-error, #ef4444) 15%, transparent);
-  color: var(--status-error, #ef4444);
-  border: 1px solid color-mix(in srgb, var(--status-error, #ef4444) 35%, transparent);
+  background: var(--status-error-bg);
+  color: var(--status-error-fg);
+  border: 1px solid var(--status-error-border);
 }
 
 .run-kpi-grid {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(min(100%, 150px), 1fr));
+  grid-template-columns: repeat(2, minmax(0, 1fr));
   gap: 8px;
   min-width: 0;
 }
+@media (max-width: 360px) { .run-kpi-grid { grid-template-columns: minmax(0, 1fr); } }
 
 .run-kpi-box {
-  background: color-mix(in srgb, var(--input-bg, #2c2c2e) 60%, transparent);
-  border: 1px solid var(--border, rgba(255, 255, 255, 0.06));
+  background: var(--bg-surface-soft, color-mix(in srgb, var(--input-bg, #2c2c2e) 45%, transparent));
+  border: 1px solid var(--border-subtle, var(--border));
   border-radius: var(--radius-md, 8px);
-  padding: 8px 10px;
+  padding: 9px 10px;
   display: flex;
   flex-direction: column;
   gap: 3px;
@@ -107,8 +137,9 @@
 }
 
 .run-kpi-value {
-  font-size: 0.95rem;
-  font-weight: 700;
+  font-size: 1rem;
+  font-variant-numeric: tabular-nums;
+  font-weight: 650;
   color: var(--text-main, #e8e8ea);
 }
 
@@ -202,14 +233,14 @@
 }
 
 .run-timeline-note-failed {
-  color: var(--status-error, #ef4444);
+  color: var(--status-error-fg, #ef4444);
   font-weight: 600;
   font-size: 0.7rem;
   flex-shrink: 0;
 }
 
 .run-timeline-note-retry {
-  color: #f59e0b;
+  color: var(--status-warning-fg, #f59e0b);
   font-weight: 600;
   font-size: 0.7rem;
   flex-shrink: 0;
@@ -300,3 +331,32 @@
   flex: 1;
   line-height: 1.3;
 }
+
+/* --- Self-Correction Guidance Card --- */
+.diagnostic-guidance-card {
+  margin-top: 8px;
+  border-radius: var(--radius-md, 8px);
+  border: 1px solid var(--border-warning, rgba(234, 179, 8, 0.3));
+  background: color-mix(in srgb, var(--status-warning-bg, #78350f) 20%, transparent);
+  padding: 8px 10px;
+  font-size: 0.74rem;
+  color: var(--text-main, #e8e8ea);
+}
+
+.diagnostic-guidance-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-bottom: 4px;
+  color: var(--status-warning-fg, #fde047);
+  font-weight: 600;
+  font-size: 0.72rem;
+}
+
+.diagnostic-guidance-card pre {
+  margin: 0;
+  font-family: var(--font-mono, ui-monospace, monospace);
+  font-size: 0.70rem;
+  white-space: pre-wrap;
+  word-break: break-word;
+}