@pheem49/mint 1.17.0 → 1.18.0

package/src/renderer/shared/constants/models.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getModelMetadata,
+  hasNativeThinkingSupport,
+  isNonTextModel,
+} from './models'
+
+describe('models thinking classification', () => {
+  it('excludes only non-text media and embedding models from thinking', () => {
+    expect(isNonTextModel('nano-banana-pro-preview')).toBe(true)
+    expect(isNonTextModel('gemini-nano-banana-2.1')).toBe(true)
+    expect(isNonTextModel('gemini-3.1-flash-image')).toBe(true)
+    expect(isNonTextModel('dall-e-3')).toBe(true)
+    expect(isNonTextModel('text-embedding-3-large')).toBe(true)
+    expect(isNonTextModel('whisper-1')).toBe(true)
+    expect(isNonTextModel('gemini-2.5-flash-native-audio-preview-12-2025')).toBe(true)
+
+    expect(getModelMetadata('nano-banana-pro-preview', 'gemini').supportsThinking).toBe(false)
+    expect(getModelMetadata('gemini-nano-banana-2.1', 'gemini').supportsThinking).toBe(false)
+  })
+
+  it('allows thinking on all text and chat models across providers', () => {
+    expect(getModelMetadata('deepseek-flash', 'deepseek').supportsThinking).toBe(true)
+    expect(getModelMetadata('deepseek-v4-pro', 'deepseek').supportsThinking).toBe(true)
+    expect(getModelMetadata('deepseek-chat', 'deepseek').supportsThinking).toBe(true)
+    expect(getModelMetadata('gemini-2.5-flash', 'gemini').supportsThinking).toBe(true)
+    expect(getModelMetadata('gemini-1.5-flash', 'gemini').supportsThinking).toBe(true)
+    expect(getModelMetadata('gpt-4o', 'openai').supportsThinking).toBe(true)
+    expect(getModelMetadata('claude-haiku-4.5', 'anthropic').supportsThinking).toBe(true)
+    expect(getModelMetadata('meta-llama/llama-3.3-70b-instruct', 'openrouter').supportsThinking).toBe(true)
+  })
+
+  it('distinguishes native reasoning API models from prompted CoT models', () => {
+    expect(hasNativeThinkingSupport('deepseek-flash', 'deepseek')).toBe(true)
+    expect(hasNativeThinkingSupport('deepseek-v4-pro', 'deepseek')).toBe(true)
+    expect(hasNativeThinkingSupport('deepseek-reasoner', 'deepseek')).toBe(true)
+    expect(hasNativeThinkingSupport('deepseek-chat', 'deepseek')).toBe(false)
+
+    expect(hasNativeThinkingSupport('gemini-2.5-flash', 'gemini')).toBe(true)
+    expect(hasNativeThinkingSupport('gemini-3.6-flash', 'gemini')).toBe(true)
+    expect(hasNativeThinkingSupport('gemini-1.5-flash', 'gemini')).toBe(false)
+
+    expect(hasNativeThinkingSupport('gpt-5.6-terra', 'openai')).toBe(true)
+    expect(hasNativeThinkingSupport('o3-mini', 'openai')).toBe(true)
+    expect(hasNativeThinkingSupport('gpt-4o', 'openai')).toBe(false)
+
+    expect(hasNativeThinkingSupport('claude-sonnet-5', 'anthropic')).toBe(true)
+    expect(hasNativeThinkingSupport('claude-haiku-4.5', 'anthropic')).toBe(true)
+    expect(hasNativeThinkingSupport('claude-3-5-sonnet', 'anthropic')).toBe(false)
+  })
+})

package/src/renderer/shared/constants/models.ts

@@ -82,6 +82,8 @@ export function isFreeModel(modelId: string): boolean {
 }
 
 export const DEEPSEEK_MODELS = [
+  'deepseek-flash',
+  'deepseek-v4-pro',
   'deepseek-chat',
   'deepseek-reasoner',
 ] as const
@@ -227,6 +229,18 @@ export const MODEL_METADATA: Record<string, ModelMeta> = {
     supportsThinking: true,
   },
 
+  // Gemini Image Generation (Nano Banana)
+  'nano-banana-pro-preview': {
+    description: 'Google Gemini Nano Banana Pro model for AI image generation and photo editing.',
+    contextWindow: '32K Context',
+    supportsThinking: false,
+  },
+  'gemini-nano-banana-2.1': {
+    description: 'Google Gemini Nano Banana 2.1 model for fast image generation and visual editing.',
+    contextWindow: '32K Context',
+    supportsThinking: false,
+  },
+
   // Anthropic Claude
   'claude-sonnet-5': {
     description: 'Anthropic flagship hybrid model with extended thinking and deep coding comprehension.',
@@ -251,7 +265,7 @@ export const MODEL_METADATA: Record<string, ModelMeta> = {
   'claude-haiku-4.5': {
     description: 'Fast and responsive Claude model for lightweight conversational turns.',
     contextWindow: '200K Context',
-    supportsThinking: false,
+    supportsThinking: true,
   },
 
   // OpenAI
@@ -283,37 +297,139 @@ export const MODEL_METADATA: Record<string, ModelMeta> = {
   'gpt-4o': {
     description: 'OpenAI versatile multimodal model for text, vision, and high-speed chat.',
     contextWindow: '128K Context',
-    supportsThinking: false,
+    supportsThinking: true,
   },
   'gpt-4o-mini': {
     description: 'Compact and fast OpenAI model for everyday conversational tasks.',
     contextWindow: '128K Context',
-    supportsThinking: false,
+    supportsThinking: true,
   },
 
   // DeepSeek
+  'deepseek-flash': {
+    description: 'DeepSeek V4.1 Flash (1M context) supporting both thinking and fast non-thinking modes.',
+    contextWindow: '1M Context',
+    supportsThinking: true,
+  },
   'deepseek-v4-flash': {
-    description: 'High-throughput DeepSeek model built for swift responses and programming.',
-    contextWindow: '128K Context',
-    supportsThinking: false,
+    description: 'High-throughput DeepSeek V4 Flash model supporting both thinking and non-thinking modes.',
+    contextWindow: '1M Context',
+    supportsThinking: true,
   },
   'deepseek-v4-pro': {
-    description: 'Advanced DeepSeek model featuring deep multilingual and coding reasoning.',
-    contextWindow: '128K Context',
+    description: 'Advanced DeepSeek V4 Pro model (1M context) featuring deep multilingual and coding reasoning.',
+    contextWindow: '1M Context',
     supportsThinking: true,
   },
   'deepseek-reasoner': {
-    description: 'DeepSeek native reasoning model (R1 architecture) with comprehensive chain-of-thought.',
-    contextWindow: '64K Context',
+    description: 'DeepSeek native reasoning model (R1 / V3.2 thinking) with comprehensive chain-of-thought.',
+    contextWindow: '128K Context',
     supportsThinking: true,
   },
   'deepseek-chat': {
-    description: 'General-purpose DeepSeek V3 conversational and coding model.',
-    contextWindow: '64K Context',
-    supportsThinking: false,
+    description: 'General-purpose DeepSeek conversational and coding model.',
+    contextWindow: '128K Context',
+    supportsThinking: true,
   },
 }
 
+/**
+ * Returns true if the model is strictly a non-text/media/embedding model
+ * (image generation, TTS, audio transcription, embeddings) that cannot use
+ * Chain-of-Thought reasoning.
+ */
+export function isNonTextModel(modelId: string): boolean {
+  const m = modelId.trim().toLowerCase()
+  const clean = m.split('/').pop() || m
+  return (
+    clean.includes('banana') ||
+    clean.includes('imagen') ||
+    clean.includes('image') ||
+    clean.includes('dall-e') ||
+    clean.includes('flux') ||
+    clean.includes('sdxl') ||
+    clean.includes('sd3') ||
+    clean.includes('ideogram') ||
+    clean.includes('veo-') ||
+    clean.includes('tts') ||
+    clean.includes('whisper') ||
+    clean.includes('embed') ||
+    clean.includes('aqa') ||
+    clean.includes('moderation') ||
+    clean.includes('native-audio') ||
+    clean.includes('-live-') ||
+    clean.endsWith('-live')
+  )
+}
+
+/**
+ * Returns true if the provider & model expose a native API parameter for visible
+ * reasoning tokens (e.g. Gemini 2.5+/3 thinkingConfig, DeepSeek V4/R1 thinking,
+ * OpenAI o1/o3/o4/gpt-5 reasoning_effort, Claude 3.7/4/5 extended thinking).
+ * Models where this returns false can still use Thinking via Prompt-based CoT (<think>).
+ */
+export function hasNativeThinkingSupport(modelId: string, provider?: string): boolean {
+  if (isNonTextModel(modelId)) return false
+  const p = (provider || '').trim().toLowerCase()
+  const m = modelId.trim().toLowerCase()
+  const clean = m.split('/').pop() || m
+
+  if (clean.includes('gemini') || p === 'gemini') {
+    return (
+      clean.startsWith('gemini-2.5') ||
+      clean.startsWith('gemini-3') ||
+      clean.includes('thinking')
+    )
+  }
+
+  if (clean.includes('claude') || p === 'anthropic') {
+    return (
+      clean.includes('3-7') ||
+      clean.includes('3.7') ||
+      clean.includes('sonnet-4') ||
+      clean.includes('opus-4') ||
+      clean.includes('haiku-4') ||
+      clean.includes('claude-4') ||
+      clean.includes('sonnet-5') ||
+      clean.includes('opus-5') ||
+      clean.includes('haiku-5') ||
+      clean.includes('thinking')
+    )
+  }
+
+  if (clean.includes('deepseek') || p === 'deepseek') {
+    return (
+      clean.includes('reasoner') ||
+      clean.includes('r1') ||
+      clean.includes('v4') ||
+      clean.includes('flash') ||
+      clean.includes('pro') ||
+      clean.includes('thinking')
+    )
+  }
+
+  if (
+    clean.startsWith('o1') ||
+    clean.startsWith('o3') ||
+    clean.startsWith('o4') ||
+    clean.startsWith('gpt-5')
+  ) {
+    return true
+  }
+
+  return (
+    clean.includes('thinking') ||
+    clean.includes('reason') ||
+    clean.includes('qwq') ||
+    clean.includes('r1') ||
+    clean.includes('qwen3') ||
+    clean.includes('glm-5') ||
+    clean.includes('glm-4.5') ||
+    clean.includes('grok-3-mini') ||
+    clean.includes('grok-4')
+  )
+}
+
 export function getModelMetadata(modelId: string, provider?: string): ModelMeta {
   const clean = modelId.trim()
   const lower = clean.toLowerCase()
@@ -331,29 +447,20 @@ export function getModelMetadata(modelId: string, provider?: string): ModelMeta
     contextWindow = lower.includes('pro') ? '2M Context' : '1M Context'
   } else if (lower.includes('claude') || provider === 'anthropic') {
     contextWindow = '200K Context'
+  } else if (lower.includes('deepseek-flash') || lower.includes('deepseek-v4')) {
+    contextWindow = '1M Context'
   } else if (lower.includes('llama-3') || lower.includes('qwen')) {
     contextWindow = '128K Context'
   }
 
-  const supportsThinking =
-    lower.includes('reason') ||
-    lower.includes('thinking') ||
-    lower.includes('r1') ||
-    lower.includes('o1') ||
-    lower.includes('o3') ||
-    lower.includes('qwq') ||
-    lower.includes('sonnet-5') ||
-    lower.includes('opus-5') ||
-    lower.includes('3-7') ||
-    lower.includes('2.5') ||
-    lower.includes('glm') ||
-    lower.includes('deepseek') ||
-    lower.includes('qwen') ||
-    (provider === 'gemini')
-
-  const description = supportsThinking
-    ? `${clean} supports advanced multi-step reasoning and dynamic thinking effort.`
-    : `${clean} is an optimized model for responsive conversational interactions.`
+  const supportsThinking = !isNonTextModel(clean)
+  const hasNative = hasNativeThinkingSupport(clean, provider)
+
+  const description = !supportsThinking
+    ? `${clean} is a specialized media or embedding model.`
+    : hasNative
+    ? `${clean} supports native multi-step reasoning and dynamic thinking effort.`
+    : `${clean} is an optimized conversational model supporting prompted chain-of-thought reasoning.`
 
   return { description, contextWindow, supportsThinking }
 }

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

@@ -18,7 +18,7 @@ const reply: ChatResponse = { provider: 'system', model: 'test', text: 'complete
 const activity: AgentProgress = { type: 'ToolStart', data: { action: 'read_file', input: { path: 'file.txt' } } }
 
 function setup(overrides: Partial<ConversationTransport> = {}, callbacks: ConversationEffects = {}, drafts?: { read(id: string): string; write(id: string, text: string): void }) {
-  const streams: Array<{ chatId: string; onProgress: (p: AgentProgress) => void; onApproval: (p: PendingApproval) => void; onStarted: (id: number) => void; result: ReturnType<typeof deferred<ChatResponse>> }> = []
+  const streams: Array<{ chatId: string; onChunk: (chunk: string) => void; onProgress: (p: AgentProgress) => void; onApproval: (p: PendingApproval) => void; onStarted: (id: number) => void; result: ReturnType<typeof deferred<ChatResponse>> }> = []
   const saved: Array<{ id: number; progress: AgentProgress[] }> = []
   const submitted: Array<{ token: string; approved: boolean; answer?: string }> = []
   const transport: ConversationTransport = {
@@ -28,10 +28,11 @@ function setup(overrides: Partial<ConversationTransport> = {}, callbacks: Conver
     saveInteractionAgentActivity: async (id: number, progress: AgentProgress[]) => { saved.push({ id, progress }) },
     cancelChatMessage: async () => {},
     clearChatHistory: async () => 1,
+    truncateInteractionsFrom: async () => 1,
     submitToolApproval: async (token: string, approved: boolean, answer?: string) => { submitted.push({ token, approved, answer }) },
-    streamChatMessage: (_message: string, _chunk: unknown, _image: unknown, _audio: unknown, _video: unknown, _instruction: unknown, onProgress: (progress: AgentProgress) => void, _document: unknown, _workspace: unknown, chatId: string, _agent: unknown, _plan: unknown, _mcp: unknown, onApproval: (approval: PendingApproval) => void, onStarted: (id: number) => void) => {
+    streamChatMessage: (_message: string, onChunk: (chunk: string) => void, _image: unknown, _audio: unknown, _video: unknown, _instruction: unknown, onProgress: (progress: AgentProgress) => void, _document: unknown, _workspace: unknown, chatId: string, _agent: unknown, _plan: unknown, _mcp: unknown, onApproval: (approval: PendingApproval) => void, onStarted: (id: number) => void) => {
       const result = deferred<ChatResponse>()
-      streams.push({ chatId, onProgress, onApproval, onStarted, result })
+      streams.push({ chatId, onChunk, onProgress, onApproval, onStarted, result })
       return result.promise
     },
     ...overrides,
@@ -521,4 +522,91 @@ describe('Queued messages lifecycle and steering', () => {
     expect(lifecycle.getSnapshot().sendingMessage).toBe('Important Urgent Turn')
     expect(streams).toHaveLength(2)
   })
+
+  it('progressively reveals streamed lines while holding incomplete tables and unclosed UI cards until completed', async () => {
+    const { lifecycle, streams } = setup()
+    const run = lifecycle.sendPrompt('Show card and table')
+
+    streams[0].onChunk('Line 1\n```ui-card\n[{"title":"Box"}]\n')
+    expect(lifecycle.getSnapshot().streamedReply).toBe('Line 1')
+
+    streams[0].onChunk('```\n| A | B |\n| - | - |\n')
+    expect(lifecycle.getSnapshot().streamedReply).toBe('Line 1\n```ui-card\n[{"title":"Box"}]\n```')
+
+    streams[0].onChunk('| 1 | 2 |\nAfter table\n')
+    expect(lifecycle.getSnapshot().streamedReply).toBe(
+      'Line 1\n```ui-card\n[{"title":"Box"}]\n```\n| A | B |\n| - | - |\n| 1 | 2 |\nAfter table',
+    )
+
+    streams[0].result.resolve({
+      provider: 'system',
+      model: 'test',
+      text: 'Line 1\n```ui-card\n[{"title":"Box"}]\n```\n| A | B |\n| - | - |\n| 1 | 2 |\nAfter table',
+    })
+    await run
+  })
+
+  it('drains a single-burst DirectText response progressively across multiple frames instead of dumping all at once', async () => {
+    const { lifecycle, streams } = setup()
+    const observedReplies: string[] = []
+    const unsubscribe = lifecycle.subscribe(() => {
+      const current = lifecycle.getSnapshot().streamedReply
+      if (current && observedReplies[observedReplies.length - 1] !== current) {
+        observedReplies.push(current)
+      }
+    })
+
+    const fullText = [
+      'Line 1',
+      'Line 2',
+      '| H1 | H2 |',
+      '| - | - |',
+      '| V1 | V2 |',
+      '```ui-card',
+      '[{"title":"Card"}]',
+      '```',
+      'Final line',
+    ].join('\n')
+
+    const run = lifecycle.sendPrompt('Direct text burst')
+    streams[0].onChunk(fullText)
+    streams[0].result.resolve({ provider: 'system', model: 'test', text: fullText })
+    await run
+    unsubscribe()
+
+    expect(observedReplies).toEqual([
+      'Line 1\nLine 2',
+      'Line 1\nLine 2\n| H1 | H2 |\n| - | - |\n| V1 | V2 |',
+      'Line 1\nLine 2\n| H1 | H2 |\n| - | - |\n| V1 | V2 |\n```ui-card\n[{"title":"Card"}]\n```',
+      fullText,
+    ])
+  })
+
+  it('truncates interactions from a given id and resends prompt', async () => {
+    let truncatedFrom: { chatId: string; fromId: number } | null = null
+    const { lifecycle, streams } = setup({
+      truncateInteractionsFrom: async (chatId, fromId) => {
+        truncatedFrom = { chatId, fromId }
+        return 1
+      },
+    })
+
+    lifecycle.appendInteraction({ id: 1, userText: 'first', aiText: 'reply 1', createdAt: '2026-01-01T00:00:00Z', provider: 'test', model: 'test' })
+    lifecycle.appendInteraction({ id: 2, userText: 'second', aiText: 'reply 2', createdAt: '2026-01-01T00:01:00Z', provider: 'test', model: 'test' })
+    lifecycle.appendInteraction({ id: 3, userText: 'third', aiText: 'reply 3', createdAt: '2026-01-01T00:02:00Z', provider: 'test', model: 'test' })
+
+    expect(lifecycle.getSnapshot().interactions).toHaveLength(3)
+
+    const resendPromise = lifecycle.resendFromInteraction(2, 'edited second')
+    expect(truncatedFrom).toEqual({ chatId: 'A', fromId: 2 })
+    expect(lifecycle.getSnapshot().interactions).toEqual([{ id: 1, userText: 'first', aiText: 'reply 1', createdAt: '2026-01-01T00:00:00Z', provider: 'test', model: 'test', chatId: 'A', status: 'completed' }])
+
+    await Promise.resolve()
+    await Promise.resolve()
+
+    streams[0].onChunk('new reply')
+    streams[0].result.resolve({ provider: 'test', model: 'test', text: 'new reply' })
+    await resendPromise
+    expect(lifecycle.getSnapshot().sending).toBe(false)
+  })
 })

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, 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,7 +54,9 @@ 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'>
@@ -100,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
@@ -256,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)
@@ -275,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 ?? []
@@ -305,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
@@ -325,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) {
@@ -349,6 +416,7 @@ 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)
@@ -399,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: {
@@ -560,6 +658,7 @@ export function createConversationLifecycle(
     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 }] }),

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',
+    )
+  })
+})