fix(files): make streamed file-preview accumulation replay-safe

Guard deriveFilePreviewSession against re-delivered/replayed content events:
apply a delta/snapshot only when previewVersion strictly advances, so a client
re-render or stream replay can't double-append the tail (the duplicated-content
bug) or regress on an older snapshot.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.test.ts

@@ -95,6 +95,80 @@ describe('deriveFilePreviewSession', () => {
     expect(next.previewVersion).toBe(9)
   })
 
+  it('ignores a re-delivered delta (same version) — no double-append (the duplication bug)', () => {
+    const prev = session({ previewText: 'the story so far.', previewVersion: 7 })
+    const replay = deriveFilePreviewSession(
+      prev,
+      {
+        previewPhase: 'file_preview_content',
+        toolCallId: 'tool-1',
+        toolName: 'workspace_file',
+        content: ' the story so far.',
+        contentMode: 'delta',
+        previewVersion: 7, // <= prev.previewVersion → a replay, must not re-append
+        fileName: 'deck.pptx',
+      },
+      'stream-1',
+      NOW
+    )
+    expect(replay.previewText).toBe('the story so far.')
+    expect(replay.previewVersion).toBe(7)
+  })
+
+  it('ignores a replayed older snapshot — no regression of accumulated text', () => {
+    const prev = session({ previewText: 'full accumulated body', previewVersion: 12 })
+    const stale = deriveFilePreviewSession(
+      prev,
+      {
+        previewPhase: 'file_preview_content',
+        toolCallId: 'tool-1',
+        toolName: 'workspace_file',
+        content: 'earlier partial',
+        contentMode: 'snapshot',
+        previewVersion: 5, // stale replay
+        fileName: 'deck.pptx',
+      },
+      'stream-1',
+      NOW
+    )
+    expect(stale.previewText).toBe('full accumulated body')
+    expect(stale.previewVersion).toBe(12)
+  })
+
+  it('re-processing the SAME delta stream N times yields the content exactly once', () => {
+    // Simulates a client re-render/re-subscribe replaying the stream: the accumulated text must be stable.
+    const deltas = [
+      { v: 1, c: 'A' },
+      { v: 2, c: 'B' },
+      { v: 3, c: 'C' },
+    ]
+    const run = (start: FilePreviewSession | undefined) =>
+      deltas.reduce<FilePreviewSession | undefined>(
+        (acc, d) =>
+          deriveFilePreviewSession(
+            acc,
+            {
+              previewPhase: 'file_preview_content',
+              toolCallId: 'tool-1',
+              toolName: 'workspace_file',
+              content: d.c,
+              contentMode: 'delta',
+              previewVersion: d.v,
+              fileName: 'deck.pptx',
+            },
+            'stream-1',
+            NOW
+          ),
+        start
+      )
+    const first = run(undefined)
+    expect(first?.previewText).toBe('ABC')
+    const second = run(first) // replay the exact same events
+    expect(second?.previewText).toBe('ABC') // NOT 'ABCABC'
+    const third = run(second)
+    expect(third?.previewText).toBe('ABC')
+  })
+
   it('replaces text on a snapshot and carries forward prior fileId', () => {
     const prev = session({ previewText: 'old', fileId: 'file-9', previewVersion: 4 })
     const next = deriveFilePreviewSession(

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.ts

@@ -71,15 +71,23 @@ export function deriveFilePreviewSession(
       return base
 
     case 'file_preview_content': {
+      const incomingVersion =
+        typeof payload.previewVersion === 'number' && Number.isFinite(payload.previewVersion)
+          ? payload.previewVersion
+          : (prev?.previewVersion ?? 0) + 1
+      // Replay-safe accumulation. A content event may be re-delivered or re-processed (a client
+      // re-render/re-subscribe, or a stream replay); `previewVersion` is monotonic per tool call, so only
+      // apply when it STRICTLY advances. Without this guard a re-delivered `delta` double-appends (the
+      // duplicated-tail bug) and a replayed older `snapshot` regresses the text. `base` already carries
+      // `prev.previewText`, so an ignored replay leaves the accumulated text untouched.
+      if (prev && incomingVersion <= prev.previewVersion) {
+        return { ...base, status: 'streaming' }
+      }
       const previewText =
         payload.contentMode === 'delta'
           ? (prev?.previewText ?? '') + payload.content
           : payload.content
-      const previewVersion =
-        typeof payload.previewVersion === 'number' && Number.isFinite(payload.previewVersion)
-          ? payload.previewVersion
-          : (prev?.previewVersion ?? 0) + 1
-      return { ...base, status: 'streaming', previewText, previewVersion }
+      return { ...base, status: 'streaming', previewText, previewVersion: incomingVersion }
     }
 
     case 'file_preview_complete':