chore: import upstream snapshot with attribution

apps/sim/lib/copilot/request/go/file-preview-adapter.ts

@@ -0,0 +1,761 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  createFilePreviewSession,
+  type FilePreviewContentMode,
+  type FilePreviewSession,
+  type FilePreviewTargetKind,
+  isToolArgsDeltaStreamEvent,
+  isToolCallStreamEvent,
+  isToolResultStreamEvent,
+  type SyntheticFilePreviewPayload,
+  upsertFilePreviewSession,
+} from '@/lib/copilot/request/session'
+import type {
+  ActiveFileIntent,
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+import { peekFileIntent } from '@/lib/copilot/tools/server/files/file-intent-store'
+import {
+  buildFilePreviewText,
+  loadWorkspaceFileTextForPreview,
+} from '@/lib/copilot/tools/server/files/file-preview'
+import { resolveWorkspaceFileReference } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('CopilotFilePreviewAdapter')
+
+type JsonRecord = Record<string, unknown>
+type FileIntent = ActiveFileIntent
+
+type EditContentStreamState = {
+  raw: string
+  lastContentSnapshot?: string
+}
+
+type FilePreviewStreamState = {
+  session: FilePreviewSession
+  lastEmittedPreviewText: string
+  lastSnapshotAt: number
+}
+
+type ParsedWorkspaceFileArgs = {
+  operation: string
+  target: FileIntent['target']
+  title?: string
+  contentType?: string
+  edit?: JsonRecord
+}
+
+const PATCH_PREVIEW_SNAPSHOT_INTERVAL_MS = 80
+const DELTA_PREVIEW_CHECKPOINT_INTERVAL_MS = 1000
+
+function asJsonRecord(value: unknown): JsonRecord | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : undefined
+}
+
+function toPreviewTargetKind(kind: string | undefined): FilePreviewTargetKind | undefined {
+  return kind === 'new_file' || kind === 'file_id' ? kind : undefined
+}
+
+async function resolvePreviewTarget(args: {
+  workspaceId?: string
+  target: FileIntent['target']
+}): Promise<FileIntent['target']> {
+  if (args.target.kind !== 'path' || !args.workspaceId || !args.target.path) {
+    return args.target
+  }
+
+  const file = await resolveWorkspaceFileReference(args.workspaceId, args.target.path)
+  if (!file) {
+    return args.target
+  }
+
+  return {
+    kind: 'file_id',
+    fileId: file.id,
+    fileName: args.target.fileName ?? file.name,
+    path: args.target.path,
+  }
+}
+
+function parseWorkspaceFileArgs(value: unknown): ParsedWorkspaceFileArgs | undefined {
+  const args = asJsonRecord(value)
+  if (!args) {
+    return undefined
+  }
+
+  const operation = typeof args.operation === 'string' ? args.operation : undefined
+  const target = asJsonRecord(args.target)
+  const targetKind = typeof target?.kind === 'string' ? target.kind : undefined
+  if (!operation || !target || !targetKind) {
+    return undefined
+  }
+
+  const fileId = typeof target.fileId === 'string' ? target.fileId : undefined
+  const fileName = typeof target.fileName === 'string' ? target.fileName : undefined
+  const path = typeof target.path === 'string' ? target.path : undefined
+  const title = typeof args.title === 'string' ? args.title : undefined
+  const contentType = typeof args.contentType === 'string' ? args.contentType : undefined
+  const edit = asJsonRecord(args.edit)
+
+  return {
+    operation,
+    target: {
+      kind: targetKind,
+      ...(fileId ? { fileId } : {}),
+      ...(fileName ? { fileName } : {}),
+      ...(path ? { path } : {}),
+    },
+    ...(title ? { title } : {}),
+    ...(contentType ? { contentType } : {}),
+    ...(edit ? { edit } : {}),
+  }
+}
+
+function extractWorkspaceFileResult(output: unknown): { fileId?: string; fileName?: string } {
+  const candidates: JsonRecord[] = []
+  const root = asJsonRecord(output)
+  if (root) {
+    candidates.push(root)
+    const rootData = asJsonRecord(root.data)
+    if (rootData) candidates.push(rootData)
+    const rootOutput = asJsonRecord(root.output)
+    if (rootOutput) {
+      candidates.push(rootOutput)
+      const outputData = asJsonRecord(rootOutput.data)
+      if (outputData) candidates.push(outputData)
+    }
+  }
+
+  for (const candidate of candidates) {
+    const fileId =
+      typeof candidate.id === 'string'
+        ? candidate.id
+        : typeof candidate.fileId === 'string'
+          ? candidate.fileId
+          : undefined
+    if (!fileId) continue
+
+    const fileName =
+      typeof candidate.name === 'string'
+        ? candidate.name
+        : typeof candidate.fileName === 'string'
+          ? candidate.fileName
+          : undefined
+    return { fileId, fileName }
+  }
+  return {}
+}
+
+export function decodeJsonStringPrefix(input: string): string {
+  let output = ''
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i]
+    if (ch !== '\\') {
+      output += ch
+      continue
+    }
+    const next = input[i + 1]
+    if (!next) break
+    if (next === 'n') {
+      output += '\n'
+      i++
+      continue
+    }
+    if (next === 't') {
+      output += '\t'
+      i++
+      continue
+    }
+    if (next === 'r') {
+      output += '\r'
+      i++
+      continue
+    }
+    if (next === '"') {
+      output += '"'
+      i++
+      continue
+    }
+    if (next === '\\') {
+      output += '\\'
+      i++
+      continue
+    }
+    if (next === '/') {
+      output += '/'
+      i++
+      continue
+    }
+    if (next === 'b') {
+      output += '\b'
+      i++
+      continue
+    }
+    if (next === 'f') {
+      output += '\f'
+      i++
+      continue
+    }
+    if (next === 'u') {
+      const hex = input.slice(i + 2, i + 6)
+      if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) break
+      output += String.fromCharCode(Number.parseInt(hex, 16))
+      i += 5
+      continue
+    }
+    break
+  }
+  return output
+}
+
+export function extractEditContent(raw: string): string {
+  const marker = '"content":'
+  const idx = raw.indexOf(marker)
+  if (idx === -1) return ''
+  const rest = raw.slice(idx + marker.length).trimStart()
+  if (!rest.startsWith('"')) return rest
+  let end = -1
+  for (let i = 1; i < rest.length; i++) {
+    if (rest[i] === '\\') {
+      i++
+      continue
+    }
+    if (rest[i] === '"') {
+      end = i
+      break
+    }
+  }
+  const inner = end === -1 ? rest.slice(1) : rest.slice(1, end)
+  return decodeJsonStringPrefix(inner)
+}
+
+function isContentOperation(
+  operation: string | undefined
+): operation is 'append' | 'update' | 'patch' {
+  return operation === 'append' || operation === 'update' || operation === 'patch'
+}
+
+function isDocFormat(fileName: string | undefined): boolean {
+  return /\.(pptx|docx|pdf)$/i.test(fileName ?? '')
+}
+
+function buildPreviewSessionFromIntent(
+  streamId: string,
+  intent: FileIntent,
+  current?: FilePreviewSession
+): FilePreviewSession {
+  const targetKind = toPreviewTargetKind(intent.target.kind)
+
+  return createFilePreviewSession({
+    streamId,
+    toolCallId: intent.toolCallId,
+    fileName: intent.target.fileName ?? current?.fileName,
+    ...(intent.target.fileId ? { fileId: intent.target.fileId } : {}),
+    ...(targetKind ? { targetKind } : {}),
+    operation: intent.operation,
+    ...(intent.edit ? { edit: intent.edit } : {}),
+    ...(typeof current?.baseContent === 'string' ? { baseContent: current.baseContent } : {}),
+    previewText: current?.previewText ?? '',
+    previewVersion: current?.previewVersion ?? 0,
+    status: current?.status ?? 'pending',
+    completedAt: current?.completedAt,
+  })
+}
+
+async function persistFilePreviewSession(session: FilePreviewSession): Promise<void> {
+  try {
+    await upsertFilePreviewSession(session)
+  } catch (error) {
+    logger.warn('Failed to persist file preview session', {
+      streamId: session.streamId,
+      toolCallId: session.toolCallId,
+      previewVersion: session.previewVersion,
+      error: toError(error).message,
+    })
+  }
+}
+
+export function buildPreviewContentUpdate(
+  previousText: string,
+  nextText: string,
+  lastSnapshotAt: number,
+  now: number,
+  operation: string | undefined
+): { content: string; contentMode: FilePreviewContentMode; lastSnapshotAt: number } {
+  const shouldForceSnapshot =
+    previousText.length === 0 ||
+    !nextText.startsWith(previousText) ||
+    operation === 'patch' ||
+    operation === 'append' ||
+    now - lastSnapshotAt >= DELTA_PREVIEW_CHECKPOINT_INTERVAL_MS
+
+  if (shouldForceSnapshot) {
+    return {
+      content: nextText,
+      contentMode: 'snapshot',
+      lastSnapshotAt: now,
+    }
+  }
+
+  return {
+    content: nextText.slice(previousText.length),
+    contentMode: 'delta',
+    lastSnapshotAt,
+  }
+}
+
+export interface FilePreviewAdapterState {
+  editContentState: Map<string, EditContentStreamState>
+  filePreviewState: Map<string, FilePreviewStreamState>
+}
+
+export function createFilePreviewAdapterState(): FilePreviewAdapterState {
+  return {
+    editContentState: new Map<string, EditContentStreamState>(),
+    filePreviewState: new Map<string, FilePreviewStreamState>(),
+  }
+}
+
+async function emitPreviewEvent(
+  streamEvent: StreamEvent,
+  options: Pick<OrchestratorOptions, 'onEvent'>,
+  payload: SyntheticFilePreviewPayload
+): Promise<void> {
+  await options.onEvent?.({
+    type: MothershipStreamV1EventType.tool,
+    payload,
+    ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+  })
+}
+
+export async function processFilePreviewStreamEvent(input: {
+  streamId: string
+  streamEvent: StreamEvent
+  context: StreamingContext
+  execContext: ExecutionContext
+  options: Pick<OrchestratorOptions, 'onEvent'>
+  state: FilePreviewAdapterState
+}): Promise<void> {
+  const { streamId, streamEvent, context, execContext, options, state } = input
+  const { editContentState, filePreviewState } = state
+
+  // Scope the in-flight intent to the invoking file subagent's channel (its
+  // outer tool_use id) so two file agents streaming concurrently never read or
+  // overwrite each other's intent. workspace_file and edit_content from the same
+  // file agent share this channel id, so they pair up; siblings stay isolated.
+  const channelId = streamEvent.scope?.parentToolCallId ?? ''
+  const getIntent = (): FileIntent | null => context.activeFileIntents.get(channelId) ?? null
+  const setIntent = (intent: FileIntent): void => {
+    context.activeFileIntents.set(channelId, intent)
+  }
+  const clearIntent = (): void => {
+    context.activeFileIntents.delete(channelId)
+  }
+
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'workspace_file') {
+    const toolCallId = streamEvent.payload.toolCallId
+    const parsedArgs = parseWorkspaceFileArgs(streamEvent.payload.arguments)
+    if (toolCallId && parsedArgs) {
+      const { operation, title, contentType, edit } = parsedArgs
+      const target = await resolvePreviewTarget({
+        workspaceId: execContext.workspaceId,
+        target: parsedArgs.target,
+      })
+      const previewTargetKind = toPreviewTargetKind(target.kind)
+      const { fileId, fileName } = target
+
+      const isContentOp = isContentOperation(operation)
+      // Per-channel: a re-declared workspace_file just overwrites THIS channel's
+      // slot. No cross-message intent clearing — that would wipe a concurrent
+      // sibling file agent's pending intent.
+      const intent: FileIntent = {
+        toolCallId,
+        operation,
+        target,
+        ...(title ? { title } : {}),
+        ...(contentType ? { contentType } : {}),
+        ...(edit ? { edit } : {}),
+      }
+      setIntent(intent)
+
+      if (isContentOp && previewTargetKind) {
+        let previewBaseContent: string | undefined
+        if (
+          execContext.workspaceId &&
+          fileId &&
+          (operation === 'append' || operation === 'patch')
+        ) {
+          previewBaseContent = await loadWorkspaceFileTextForPreview(
+            execContext.workspaceId,
+            fileId
+          )
+        }
+
+        let session = buildPreviewSessionFromIntent(streamId, intent)
+        if (previewBaseContent !== undefined) {
+          session = { ...session, baseContent: previewBaseContent }
+        }
+        filePreviewState.set(toolCallId, {
+          session,
+          lastEmittedPreviewText: '',
+          lastSnapshotAt: 0,
+        })
+        await persistFilePreviewSession(session)
+
+        await emitPreviewEvent(streamEvent, options, {
+          toolCallId,
+          toolName: 'workspace_file',
+          previewPhase: 'file_preview_start',
+        })
+        await emitPreviewEvent(streamEvent, options, {
+          toolCallId,
+          toolName: 'workspace_file',
+          previewPhase: 'file_preview_target',
+          operation,
+          target: {
+            kind: previewTargetKind,
+            ...(fileId ? { fileId } : {}),
+            ...(fileName ? { fileName } : {}),
+          },
+          ...(title ? { title } : {}),
+        })
+        if (edit) {
+          await emitPreviewEvent(streamEvent, options, {
+            toolCallId,
+            toolName: 'workspace_file',
+            previewPhase: 'file_preview_edit_meta',
+            edit,
+          })
+        }
+      }
+    }
+  }
+
+  const workspaceResultIntent = getIntent()
+  if (
+    isToolResultStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'workspace_file' &&
+    workspaceResultIntent &&
+    isContentOperation(workspaceResultIntent.operation)
+  ) {
+    const result = extractWorkspaceFileResult(streamEvent.payload.output)
+    if (result.fileId && workspaceResultIntent.target.kind === 'path') {
+      const intent: FileIntent = {
+        ...workspaceResultIntent,
+        target: {
+          kind: 'file_id',
+          fileId: result.fileId,
+          fileName: result.fileName ?? workspaceResultIntent.target.fileName,
+          path: workspaceResultIntent.target.path,
+        },
+      }
+      setIntent(intent)
+
+      let previewBaseContent: string | undefined
+      if (
+        execContext.workspaceId &&
+        (intent.operation === 'append' || intent.operation === 'patch')
+      ) {
+        previewBaseContent = await loadWorkspaceFileTextForPreview(
+          execContext.workspaceId,
+          result.fileId
+        )
+      }
+
+      let session = buildPreviewSessionFromIntent(streamId, intent)
+      if (previewBaseContent !== undefined) {
+        session = { ...session, baseContent: previewBaseContent }
+      }
+      filePreviewState.set(intent.toolCallId, {
+        session,
+        lastEmittedPreviewText: '',
+        lastSnapshotAt: 0,
+      })
+      await persistFilePreviewSession(session)
+
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: intent.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_start',
+      })
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: intent.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_target',
+        operation: intent.operation,
+        target: {
+          kind: 'file_id',
+          fileId: result.fileId,
+          ...(result.fileName ? { fileName: result.fileName } : {}),
+        },
+        ...(intent.title ? { title: intent.title } : {}),
+      })
+      if (intent.edit) {
+        await emitPreviewEvent(streamEvent, options, {
+          toolCallId: intent.toolCallId,
+          toolName: 'workspace_file',
+          previewPhase: 'file_preview_edit_meta',
+          edit: intent.edit,
+        })
+      }
+    }
+  }
+
+  const patchDeleteIntent = getIntent()
+  if (
+    isToolResultStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'workspace_file' &&
+    patchDeleteIntent &&
+    isContentOperation(patchDeleteIntent.operation) &&
+    patchDeleteIntent.operation === 'patch' &&
+    patchDeleteIntent.edit?.strategy === 'anchored' &&
+    patchDeleteIntent.edit?.mode === 'delete_between' &&
+    execContext.workspaceId &&
+    patchDeleteIntent.target.fileId &&
+    !isDocFormat(patchDeleteIntent.target.fileName)
+  ) {
+    const currentPreview = filePreviewState.get(patchDeleteIntent.toolCallId)
+    const previewText = buildFilePreviewText({
+      operation: 'patch',
+      streamedContent: '',
+      existingContent: currentPreview?.session.baseContent,
+      edit: currentPreview?.session.edit,
+    })
+
+    if (previewText !== undefined) {
+      const baseSession = buildPreviewSessionFromIntent(
+        streamId,
+        patchDeleteIntent,
+        currentPreview?.session
+      )
+      const nextSession: FilePreviewSession = {
+        ...baseSession,
+        status: 'streaming',
+        previewText,
+        previewVersion: (currentPreview?.session.previewVersion ?? 0) + 1,
+        updatedAt: new Date().toISOString(),
+      }
+      filePreviewState.set(patchDeleteIntent.toolCallId, {
+        session: nextSession,
+        lastEmittedPreviewText: previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await persistFilePreviewSession(nextSession)
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: nextSession.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_content',
+        content: previewText,
+        contentMode: 'snapshot',
+        previewVersion: nextSession.previewVersion,
+        fileName: nextSession.fileName,
+        ...(nextSession.fileId ? { fileId: nextSession.fileId } : {}),
+        ...(nextSession.targetKind ? { targetKind: nextSession.targetKind } : {}),
+        ...(nextSession.operation ? { operation: nextSession.operation } : {}),
+        ...(nextSession.edit ? { edit: nextSession.edit } : {}),
+      })
+    }
+  }
+
+  if (isToolArgsDeltaStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+    const toolCallId = streamEvent.payload.toolCallId
+    const delta = streamEvent.payload.argumentsDelta
+    const stateForTool = editContentState.get(toolCallId) ?? { raw: '' }
+    stateForTool.raw += delta
+
+    const editIntent = getIntent()
+    if (editIntent) {
+      const streamedContent = extractEditContent(stateForTool.raw)
+      if (streamedContent !== (stateForTool.lastContentSnapshot ?? '')) {
+        stateForTool.lastContentSnapshot = streamedContent
+        let currentPreview = filePreviewState.get(editIntent.toolCallId) ?? {
+          session: buildPreviewSessionFromIntent(streamId, editIntent),
+          lastEmittedPreviewText: '',
+          lastSnapshotAt: 0,
+        }
+
+        if (
+          currentPreview.session.baseContent === undefined &&
+          (editIntent.operation === 'append' || editIntent.operation === 'patch') &&
+          execContext.workspaceId &&
+          editIntent.target.fileId
+        ) {
+          const intentBase = await peekFileIntent(
+            execContext.workspaceId,
+            editIntent.target.fileId,
+            {
+              chatId: execContext.chatId,
+              messageId: execContext.messageId,
+              channelId,
+            }
+          )
+          if (typeof intentBase?.existingContent === 'string') {
+            const seededSession: FilePreviewSession = {
+              ...currentPreview.session,
+              baseContent: intentBase.existingContent,
+              ...(intentBase.edit ? { edit: intentBase.edit } : {}),
+            }
+            currentPreview = {
+              ...currentPreview,
+              session: seededSession,
+            }
+            filePreviewState.set(editIntent.toolCallId, currentPreview)
+            await persistFilePreviewSession(seededSession)
+          }
+        }
+
+        const previewText = isContentOperation(editIntent.operation)
+          ? buildFilePreviewText({
+              operation: editIntent.operation,
+              streamedContent,
+              existingContent: currentPreview.session.baseContent,
+              edit: currentPreview.session.edit,
+            })
+          : undefined
+
+        if (previewText !== undefined) {
+          const baseSession = buildPreviewSessionFromIntent(
+            streamId,
+            editIntent,
+            currentPreview.session
+          )
+          const now = Date.now()
+          const nextSession: FilePreviewSession = {
+            ...baseSession,
+            status: 'streaming',
+            previewText,
+            previewVersion: (currentPreview.session.previewVersion ?? 0) + 1,
+            updatedAt: new Date(now).toISOString(),
+          }
+
+          await persistFilePreviewSession(nextSession)
+
+          if (
+            nextSession.operation === 'patch' &&
+            now - currentPreview.lastSnapshotAt < PATCH_PREVIEW_SNAPSHOT_INTERVAL_MS
+          ) {
+            filePreviewState.set(editIntent.toolCallId, {
+              session: nextSession,
+              lastEmittedPreviewText: currentPreview.lastEmittedPreviewText,
+              lastSnapshotAt: currentPreview.lastSnapshotAt,
+            })
+          } else {
+            const previewUpdate = buildPreviewContentUpdate(
+              currentPreview.lastEmittedPreviewText,
+              nextSession.previewText,
+              currentPreview.lastSnapshotAt,
+              now,
+              nextSession.operation
+            )
+
+            filePreviewState.set(editIntent.toolCallId, {
+              session: nextSession,
+              lastEmittedPreviewText: nextSession.previewText,
+              lastSnapshotAt: previewUpdate.lastSnapshotAt,
+            })
+
+            await emitPreviewEvent(streamEvent, options, {
+              toolCallId: nextSession.toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_content',
+              content: previewUpdate.content,
+              contentMode: previewUpdate.contentMode,
+              previewVersion: nextSession.previewVersion,
+              fileName: nextSession.fileName,
+              ...(nextSession.fileId ? { fileId: nextSession.fileId } : {}),
+              ...(nextSession.targetKind ? { targetKind: nextSession.targetKind } : {}),
+              ...(nextSession.operation ? { operation: nextSession.operation } : {}),
+              ...(nextSession.edit ? { edit: nextSession.edit } : {}),
+            })
+          }
+        } else {
+          filePreviewState.set(editIntent.toolCallId, {
+            session: currentPreview.session,
+            lastEmittedPreviewText: currentPreview.lastEmittedPreviewText,
+            lastSnapshotAt: currentPreview.lastSnapshotAt,
+          })
+        }
+      }
+    }
+
+    editContentState.set(toolCallId, stateForTool)
+  }
+
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+    const toolCallId = streamEvent.payload.toolCallId
+    if (toolCallId) {
+      editContentState.delete(toolCallId)
+    }
+  }
+
+  const editResultIntent = getIntent()
+  if (
+    isToolResultStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'edit_content' &&
+    editResultIntent
+  ) {
+    const currentPreview = filePreviewState.get(editResultIntent.toolCallId)
+    const completedAt = new Date().toISOString()
+
+    if (
+      currentPreview &&
+      currentPreview.lastEmittedPreviewText !== currentPreview.session.previewText &&
+      currentPreview.session.previewText.length > 0
+    ) {
+      filePreviewState.set(editResultIntent.toolCallId, {
+        session: currentPreview.session,
+        lastEmittedPreviewText: currentPreview.session.previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: currentPreview.session.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_content',
+        content: currentPreview.session.previewText,
+        contentMode: 'snapshot',
+        previewVersion: currentPreview.session.previewVersion,
+        fileName: currentPreview.session.fileName,
+        ...(currentPreview.session.fileId ? { fileId: currentPreview.session.fileId } : {}),
+        ...(currentPreview.session.targetKind
+          ? { targetKind: currentPreview.session.targetKind }
+          : {}),
+        ...(currentPreview.session.operation
+          ? { operation: currentPreview.session.operation }
+          : {}),
+        ...(currentPreview.session.edit ? { edit: currentPreview.session.edit } : {}),
+      })
+    }
+
+    if (currentPreview) {
+      const completedSession: FilePreviewSession = {
+        ...currentPreview.session,
+        status: 'complete',
+        updatedAt: completedAt,
+        completedAt,
+      }
+      filePreviewState.set(editResultIntent.toolCallId, {
+        session: completedSession,
+        lastEmittedPreviewText: completedSession.previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await persistFilePreviewSession(completedSession)
+    }
+
+    await emitPreviewEvent(streamEvent, options, {
+      toolCallId: editResultIntent.toolCallId,
+      toolName: 'workspace_file',
+      previewPhase: 'file_preview_complete',
+      fileId: editResultIntent.target.fileId,
+      output: streamEvent.payload.output,
+      ...(currentPreview ? { previewVersion: currentPreview.session.previewVersion } : {}),
+    })
+    clearIntent()
+  }
+}