@pheem49/mint 1.16.0 → 1.18.0

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

@@ -2,13 +2,14 @@ import { initialConversationState, transitionConversation, type ConversationEven
 import { compactAgentProgressForPersistence, mergeActivitySnapshots } from '../agentProgress'
 import { requiresExplicitApproval } from '../utils/approval'
 import { navigateToProject } from './projectNavigation'
+import { createProgressiveStreamPacer, type ProgressiveStreamPacer } from './progressiveStream'
 import type { MintPlatformApi } from '../platform'
-import type { AgentProgress, ChatResponse, ChatSession, InteractionMemory } from '../types'
+import type { AgentProgress, ChatResponse, ChatSession, InteractionMemory, QueuedPrompt } from '../types'
 
 export type ConversationTransport = Pick<MintPlatformApi,
   | 'getConversationSnapshot' | 'getConversationChanges' | 'listChatSessions'
   | 'streamChatMessage' | 'cancelChatMessage' | 'submitToolApproval'
-  | 'saveInteractionAgentActivity' | 'clearChatHistory'>
+  | 'saveInteractionAgentActivity' | 'clearChatHistory' | 'truncateInteractionsFrom'>
 
 export interface PendingApproval { token: string; approval: Record<string, unknown> }
 export interface ConversationView extends ConversationState {
@@ -53,13 +54,21 @@ interface Run {
   autoApprove: boolean
   progress: AgentProgress[]
   queuedProgress: AgentProgress[]
+  pacer: ProgressiveStreamPacer
   timer?: ReturnType<typeof setTimeout>
+  streamTimer?: ReturnType<typeof setTimeout>
 }
 export interface ConversationBrowser {
   window: Pick<Window, 'addEventListener' | 'removeEventListener' | 'setInterval' | 'clearInterval'>
   document: Pick<Document, 'visibilityState' | 'addEventListener' | 'removeEventListener'>
 }
 
+export function conversationPollIntervalsMs(activeRun: boolean): { historyMs: number; sessionsMs: number } {
+  return activeRun
+    ? { historyMs: 1500, sessionsMs: 5000 }
+    : { historyMs: 5000, sessionsMs: 15000 }
+}
+
 /** Owns ordering and lifecycle; callers never handle generations or cursors. */
 export function createConversationLifecycle(
   conversationId: string,
@@ -82,6 +91,8 @@ export function createConversationLifecycle(
   const pendingSubmissions = new Map<string, { signature: string; requestId: string }>()
   const runs = new Map<string, Run>()
   const subscribers = new Set<() => void>()
+  const conversationQueuedPrompts = new Map<string, QueuedPrompt[]>()
+  const conversationQueuePaused = new Map<string, boolean>()
   const update = (patch: Partial<ConversationView>) => {
     state = { ...state, ...patch }
     subscribers.forEach(notify => notify())
@@ -92,6 +103,21 @@ export function createConversationLifecycle(
     if (run.timer !== undefined) clearTimeout(run.timer)
     run.timer = undefined
   }
+  const clearStreamTimer = (run: Run) => {
+    if (run.streamTimer !== undefined) clearTimeout(run.streamTimer)
+    run.streamTimer = undefined
+  }
+  const stepStreamPacer = (run: Run) => {
+    clearStreamTimer(run)
+    if (!currentRun(run)) return
+    const revealed = run.pacer.step()
+    if (revealed !== null) {
+      update({ streamedReply: revealed })
+      if (!run.pacer.isDone()) {
+        run.streamTimer = setTimeout(() => stepStreamPacer(run), 18)
+      }
+    }
+  }
   const flushProgress = (run: Run) => {
     clearProgressTimer(run)
     const batch = run.queuedProgress
@@ -121,8 +147,11 @@ export function createConversationLifecycle(
     session = { chatId: id }
     cursor = null
     projectSerial++
+    const activePrompts = conversationQueuedPrompts.get(id) || []
+    const activePaused = conversationQueuePaused.get(id) || false
     update({
       ...transitionConversation(state, { type: 'session_switched', draft }), conversationId: id,
+      queuedPrompts: activePrompts, queuePaused: activePaused,
       interactions: [], hasOlderInteractions: false, agentActivitySnapshots: {},
       streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false,
     })
@@ -245,6 +274,7 @@ export function createConversationLifecycle(
     if (!state.sending || !run || !currentRun(run)) return
     runs.delete(origin.chatId)
     clearProgressTimer(run)
+    clearStreamTimer(run)
     const approvalToken = state.pendingApprovals[origin.chatId]?.token
     try {
       await transport.cancelChatMessage(origin.chatId)
@@ -252,8 +282,10 @@ export function createConversationLifecycle(
       if (origin === session) effects.onError?.(error)
     } finally {
       if (approvalToken) removeApproval(origin.chatId, approvalToken)
+      conversationQueuePaused.set(origin.chatId, true)
       if (origin === session && !runs.has(origin.chatId)) {
         update({ ...transitionConversation(state, { type: 'run_cancelled' }),
+          queuePaused: true,
           streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
       }
     }
@@ -262,7 +294,7 @@ export function createConversationLifecycle(
   async function sendPrompt(prompt: string, options: PromptOptions = {}) {
     if (state.sending) return
     const origin = session
-    const run: Run = { session: origin, turnId: null, autoApprove: false, progress: [], queuedProgress: [] }
+    const run: Run = { session: origin, turnId: null, autoApprove: false, progress: [], queuedProgress: [], pacer: createProgressiveStreamPacer() }
     runs.set(origin.chatId, run)
     const images = options.imageAttachments ?? []
     const videos = options.videoAttachments ?? []
@@ -271,7 +303,15 @@ export function createConversationLifecycle(
     update({ ...transitionConversation(state, { type: 'run_started', message: prompt, imageCount: images.length, videoCount: videos.length }),
       streamingConversationId: origin.chatId, activeTurnId: null, sessionAutoApproved: false })
     const draft = { message: state.message, images: state.imageAttachments, videos: state.videoAttachments, document: state.documentAttachment }
-    const signature = JSON.stringify([prompt, images, videos, options.documentAttachment])
+    const uriFingerprint = (name: string, dataUri: string) =>
+      `${name}:${dataUri.length}:${dataUri.slice(0, 64)}:${dataUri.slice(-32)}`
+    const doc = options.documentAttachment
+    const signature = [
+      prompt,
+      images.map(i => uriFingerprint(i.name, i.dataUri)).join('|'),
+      videos.map(v => uriFingerprint(v.name, v.dataUri)).join('|'),
+      doc ? uriFingerprint(doc.filename, doc.dataUri) : '',
+    ].join('\u0000')
     let submission = pendingSubmissions.get(origin.chatId)
     if (submission?.signature !== signature) {
       submission = { signature, requestId: globalThis.crypto?.randomUUID?.() ?? `submission-${Date.now().toString(36)}-${Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16)), byte => byte.toString(16).padStart(2, '0')).join('')}` }
@@ -284,7 +324,27 @@ export function createConversationLifecycle(
     }
     try {
       const response = await transport.streamChatMessage(
-        agent ? prompt : `/chat ${prompt}`, () => {}, images.map(img => img.dataUri).join(' '),
+        agent ? prompt : `/chat ${prompt}`,
+        chunk => {
+          if (runs.get(origin.chatId) !== run) return
+          run.pacer.pushDelta(chunk)
+          if (!currentRun(run)) return
+          // Immediately reveal up to 2 ready units (e.g. a completed table + following line);
+          // if a larger multi-line burst arrived at once, pace the remaining units smoothly.
+          let latest: string | null = null
+          for (let i = 0; i < 2; i++) {
+            const next = run.pacer.step()
+            if (next === null) break
+            latest = next
+          }
+          if (latest !== null) {
+            update({ streamedReply: latest })
+            if (run.streamTimer === undefined) {
+              run.streamTimer = setTimeout(() => stepStreamPacer(run), 18)
+            }
+          }
+        },
+        images.map(img => img.dataUri).join(' '),
         options.audioDataUri ?? null, videos.map(video => video.dataUri).join(' '), options.systemInstruction ?? '',
         progress => {
           if (runs.get(origin.chatId) !== run) return
@@ -304,8 +364,36 @@ export function createConversationLifecycle(
       )
       if (response.provider !== 'error') accepted()
       flushProgress(run)
-      // Reveal only the authoritative completed reply, as on CLI/TUI.
-      if (currentRun(run)) update({ streamedReply: response.text, streamedResponse: response })
+      clearStreamTimer(run)
+      run.pacer.finish(response.text)
+      if (currentRun(run)) {
+        const firstStep = run.pacer.step()
+        if (firstStep !== null) {
+          update({ streamedReply: firstStep, streamedResponse: response })
+        }
+        const usingFakeTimers = typeof (globalThis as any).vi?.isFakeTimers === 'function'
+          && (globalThis as any).vi.isFakeTimers()
+        if (!usingFakeTimers) {
+          while (!run.pacer.isDone() && runs.get(origin.chatId) === run && currentRun(run)) {
+            await new Promise<void>(resolve => {
+              run.streamTimer = setTimeout(() => {
+                run.streamTimer = undefined
+                resolve()
+              }, 18)
+            })
+            if (runs.get(origin.chatId) !== run || !currentRun(run)) break
+            const next = run.pacer.step()
+            if (next !== null) {
+              update({ streamedReply: next, streamedResponse: response })
+            } else {
+              break
+            }
+          }
+        }
+        if (runs.get(origin.chatId) === run && currentRun(run)) {
+          update({ streamedReply: run.pacer.flushAll(), streamedResponse: response })
+        }
+      }
       await effects.onReply?.(response, origin.chatId)
       const persisted = compactAgentProgressForPersistence(run.progress)
       if (persisted.length && run.turnId !== null) {
@@ -328,11 +416,33 @@ export function createConversationLifecycle(
       if (currentRun(run)) effects.onError?.(error)
     } finally {
       flushProgress(run)
+      clearStreamTimer(run)
       if (runs.get(origin.chatId) === run) {
+        const isCurrent = currentRun(run)
         removeApproval(origin.chatId)
-        if (currentRun(run)) update({ ...transitionConversation(state, { type: 'run_finished' }),
-          streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
         runs.delete(origin.chatId)
+        if (isCurrent) {
+          update({ ...transitionConversation(state, { type: 'run_finished' }),
+            streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
+        } else {
+          subscribers.forEach(notify => notify())
+        }
+        const isPaused = conversationQueuePaused.get(origin.chatId) || false
+        const chatQueue = conversationQueuedPrompts.get(origin.chatId) || []
+        if (!isPaused && chatQueue.length > 0) {
+          const next = chatQueue.shift()!
+          conversationQueuedPrompts.set(origin.chatId, chatQueue)
+          if (origin === session) {
+            dispatch({ type: 'queued_prompt_dequeued', id: next.id })
+          }
+          void sendPrompt(next.text, {
+            imageAttachments: next.imageAttachments,
+            videoAttachments: next.videoAttachments,
+            documentAttachment: next.documentAttachment,
+            agentMode: options.agentMode,
+            planMode: options.planMode,
+          })
+        }
       }
     }
   }
@@ -357,6 +467,36 @@ export function createConversationLifecycle(
     }
   }
 
+  async function truncateFrom(fromId: number) {
+    const origin = session
+    try {
+      if (state.sending && runs.has(origin.chatId)) {
+        await cancel()
+      }
+      // Optimistically update local state immediately so UI updates with zero latency
+      const filtered = state.interactions.filter(i => i.id < fromId)
+      const snapshots = { ...state.agentActivitySnapshots }
+      for (const interaction of state.interactions) {
+        if (interaction.id >= fromId) {
+          delete snapshots[String(interaction.id)]
+        }
+      }
+      update({
+        interactions: filtered,
+        agentActivitySnapshots: snapshots,
+        activeTurnId: null,
+      })
+      await transport.truncateInteractionsFrom(origin.chatId, fromId)
+    } catch (error) {
+      if (origin === session) throw error
+    }
+  }
+
+  async function resendFromInteraction(fromId: number, promptText: string, options: PromptOptions = {}) {
+    await truncateFrom(fromId)
+    await sendPrompt(promptText, options)
+  }
+
   async function selectProject(
     choosePath: () => Promise<string | null>,
     navigation: {
@@ -381,29 +521,145 @@ export function createConversationLifecycle(
 
   function watch(browser: ConversationBrowser, historyVisible: boolean) {
     let active = true
+    let activeRun = state.sending || runs.size > 0
+    let historyTimer: number | undefined
+    let sessionsTimer: number | undefined
+
     const visible = () => active && browser.document.visibilityState === 'visible'
     const sync = () => { if (historyVisible && visible()) void syncHistory(visible) }
     const refresh = () => { if (visible()) void refreshSessions().catch(() => {}) }
     const focus = () => { sync(); refresh() }
+
+    const scheduleTimers = () => {
+      if (historyTimer !== undefined) browser.window.clearInterval(historyTimer)
+      if (sessionsTimer !== undefined) browser.window.clearInterval(sessionsTimer)
+      if (!active) return
+
+      const intervals = conversationPollIntervalsMs(activeRun)
+      historyTimer = historyVisible ? browser.window.setInterval(sync, intervals.historyMs) : undefined
+      sessionsTimer = browser.window.setInterval(refresh, intervals.sessionsMs)
+    }
+
+    const checkActiveRunTransition = () => {
+      const currentActive = state.sending || runs.size > 0
+      if (currentActive !== activeRun) {
+        activeRun = currentActive
+        scheduleTimers()
+        if (activeRun) {
+          sync()
+          refresh()
+        }
+      }
+    }
+
+    subscribers.add(checkActiveRunTransition)
     sync()
-    const historyTimer = historyVisible ? browser.window.setInterval(sync, 1500) : undefined
-    const sessionsTimer = browser.window.setInterval(refresh, 5000)
+    scheduleTimers()
+
     browser.window.addEventListener('focus', focus)
     browser.document.addEventListener('visibilitychange', focus)
     return () => {
       active = false
+      subscribers.delete(checkActiveRunTransition)
       if (historyTimer !== undefined) browser.window.clearInterval(historyTimer)
-      browser.window.clearInterval(sessionsTimer)
+      if (sessionsTimer !== undefined) browser.window.clearInterval(sessionsTimer)
       browser.window.removeEventListener('focus', focus)
       browser.document.removeEventListener('visibilitychange', focus)
     }
   }
 
+  function queuePrompt(data: {
+    text: string
+    imageAttachments?: ConversationState['imageAttachments']
+    videoAttachments?: ConversationState['videoAttachments']
+    documentAttachment?: ConversationState['documentAttachment']
+  }) {
+    const id = `q-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+    const prompt: QueuedPrompt = {
+      id,
+      chatId: session.chatId,
+      text: data.text,
+      imageAttachments: data.imageAttachments && data.imageAttachments.length > 0 ? [...data.imageAttachments] : undefined,
+      videoAttachments: data.videoAttachments && data.videoAttachments.length > 0 ? [...data.videoAttachments] : undefined,
+      documentAttachment: data.documentAttachment || null,
+      createdAt: Date.now(),
+    }
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    conversationQueuedPrompts.set(session.chatId, [...current, prompt])
+    conversationQueuePaused.set(session.chatId, false)
+    dispatch({ type: 'prompt_queued', prompt })
+  }
+
+  function removeQueuedPrompt(id: string) {
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    conversationQueuedPrompts.set(session.chatId, current.filter(p => p.id !== id))
+    dispatch({ type: 'queued_prompt_removed', id })
+  }
+
+  function editQueuedPrompt(id: string) {
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    const found = current.find(p => p.id === id)
+    if (!found) return
+    conversationQueuedPrompts.set(session.chatId, current.filter(p => p.id !== id))
+    dispatch({ type: 'queued_prompt_restored_to_composer', prompt: found })
+  }
+
+  function clearQueuedPrompts() {
+    conversationQueuedPrompts.delete(session.chatId)
+    conversationQueuePaused.set(session.chatId, false)
+    dispatch({ type: 'queued_prompts_cleared' })
+  }
+
+  function setQueuePaused(paused: boolean) {
+    conversationQueuePaused.set(session.chatId, paused)
+    dispatch({ type: 'queue_paused_set', paused })
+  }
+
+  function resumeQueue() {
+    setQueuePaused(false)
+    if (!state.sending) {
+      const current = conversationQueuedPrompts.get(session.chatId) || []
+      const next = current[0]
+      if (next) {
+        conversationQueuedPrompts.set(session.chatId, current.slice(1))
+        dispatch({ type: 'queued_prompt_dequeued', id: next.id })
+        void sendPrompt(next.text, {
+          imageAttachments: next.imageAttachments,
+          videoAttachments: next.videoAttachments,
+          documentAttachment: next.documentAttachment,
+        })
+      }
+    }
+  }
+
+  async function steerQueuedPrompt(id: string) {
+    const origin = session
+    const current = conversationQueuedPrompts.get(origin.chatId) || []
+    const found = current.find(p => p.id === id)
+    if (!found) return
+    conversationQueuedPrompts.set(origin.chatId, current.filter(p => p.id !== id))
+    conversationQueuePaused.set(origin.chatId, false)
+    if (origin === session) {
+      dispatch({ type: 'queued_prompt_dequeued', id })
+      dispatch({ type: 'queue_paused_set', paused: false })
+    }
+    if (state.sending && runs.has(origin.chatId)) {
+      await cancel()
+    }
+    void sendPrompt(found.text, {
+      imageAttachments: found.imageAttachments,
+      videoAttachments: found.videoAttachments,
+      documentAttachment: found.documentAttachment,
+    })
+  }
+
   return {
     getSnapshot: () => state,
     subscribe: (notify: () => void) => { subscribers.add(notify); return () => { subscribers.delete(notify) } },
     activate, refreshHistory, refreshSessions, syncHistory, loadOlder, sendPrompt, cancel,
     receiveApproval, resolveApproval, clearHistory, selectProject, watch,
+    truncateFrom, resendFromInteraction,
+    queuePrompt, removeQueuedPrompt, editQueuedPrompt, clearQueuedPrompts, setQueuePaused, resumeQueue, steerQueuedPrompt,
     appendInteraction: (row: Omit<InteractionMemory, 'chatId' | 'status'> & Partial<Pick<InteractionMemory, 'chatId' | 'status'>>) =>
       update({ interactions: [...state.interactions, { chatId: session.chatId, status: 'completed', ...row }] }),
     compose: (message: string) => dispatch({ type: 'compose', message }),

package/src/renderer/shared/conversation/progressiveStream.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import {
+  extractRenderableStreamPrefix,
+  splitProgressiveStreamUnits,
+  createProgressiveStreamPacer,
+} from './progressiveStream'
+
+describe('progressiveStream (Line-by-Line + Block-Aware)', () => {
+  it('releases normal paragraphs and regular code blocks line by line while holding incomplete tables and unclosed UI cards', () => {
+    const partialTable = 'Intro paragraph\n| Name | Role |\n| --- | --- |\n| Alice | Admin |\n'
+    expect(extractRenderableStreamPrefix(partialTable, false)).toBe('Intro paragraph')
+    expect(extractRenderableStreamPrefix(partialTable, true)).toBe(partialTable.trimEnd())
+
+    const completedTable = `${partialTable}Summary after table\n`
+    expect(extractRenderableStreamPrefix(completedTable, false)).toBe(completedTable.trimEnd())
+
+    const partialUiCard = 'Before card\n```ui-card\n[{"title": "Fast", "subtitle": "Card"}]\n'
+    expect(extractRenderableStreamPrefix(partialUiCard, false)).toBe('Before card')
+
+    const closedUiCard = `${partialUiCard}\`\`\`\nAfter card\n`
+    expect(extractRenderableStreamPrefix(closedUiCard, false)).toBe(closedUiCard.trimEnd())
+
+    const bareFence = 'Before code\n```ts\n'
+    expect(extractRenderableStreamPrefix(bareFence, false)).toBe('Before code')
+
+    const partialCode = 'Before code\n```ts\nconst x = 1\n'
+    expect(extractRenderableStreamPrefix(partialCode, false)).toBe('Before code\n```ts\nconst x = 1')
+
+    const unlabeledUiCard = 'Before card\n```\nui-card [\n  {"title": "Fast"}\n]\n'
+    expect(extractRenderableStreamPrefix(unlabeledUiCard, false)).toBe('Before card')
+    expect(extractRenderableStreamPrefix(`${unlabeledUiCard}\`\`\`\n`, false)).toBe(
+      `${unlabeledUiCard}\`\`\``,
+    )
+  })
+
+  it('splits complete markdown into line units for text/code and atomic block units for tables and JSON/Mermaid cards', () => {
+    const doc = [
+      '# Title',
+      'First line',
+      '| A | B |',
+      '| - | - |',
+      '| 1 | 2 |',
+      '```python',
+      'print(42)',
+      '```',
+      '```ui-grid',
+      '[{"title": "Item"}]',
+      '```',
+      'Done',
+    ].join('\n')
+
+    expect(splitProgressiveStreamUnits(doc, true)).toEqual([
+      '# Title',
+      'First line',
+      '| A | B |\n| - | - |\n| 1 | 2 |',
+      '```python\nprint(42)',
+      '```',
+      '```ui-grid\n[{"title": "Item"}]\n```',
+      'Done',
+    ])
+  })
+
+  it('paces deltas and authoritative final text smoothly in order without leaking raw JSON mid-card', () => {
+    const revealed: string[] = []
+    const pacer = createProgressiveStreamPacer((text) => revealed.push(text))
+
+    pacer.pushDelta('Line 1\n```ui-card\n[{"title":"Box"}]\n')
+    expect(pacer.step()).toBe('Line 1')
+    expect(pacer.step()).toBeNull()
+
+    pacer.pushDelta('```\nLine 2\n')
+    expect(pacer.step()).toBe('Line 1\n```ui-card\n[{"title":"Box"}]\n```')
+    expect(pacer.step()).toBe('Line 1\n```ui-card\n[{"title":"Box"}]\n```\nLine 2')
+    expect(pacer.isDone()).toBe(false)
+
+    pacer.finish('Line 1\n```ui-card\n[{"title":"Box"}]\n```\nLine 2\nFinal tail')
+    expect(pacer.flushAll()).toBe('Line 1\n```ui-card\n[{"title":"Box"}]\n```\nLine 2\nFinal tail')
+    expect(pacer.isDone()).toBe(true)
+    expect(revealed[revealed.length - 1]).toBe(
+      'Line 1\n```ui-card\n[{"title":"Box"}]\n```\nLine 2\nFinal tail',
+    )
+  })
+})