fix(uploads): manual uploads provenance ignore

Author: icecrasher321

apps/sim/executor/handlers/agent/agent-handler.test.ts

@@ -18,6 +18,7 @@ import {
   vi,
 } from 'vitest'
 import type { AutoRoutingSignals } from '@/lib/model-router/resolve'
+import * as userFileBase64 from '@/lib/uploads/utils/user-file-base64.server'
 import { getAllBlocks } from '@/blocks'
 import { AGENT, BlockType, isMcpTool } from '@/executor/constants'
 import { AgentBlockHandler } from '@/executor/handlers/agent/agent-handler'
@@ -469,6 +470,47 @@ describe('AgentBlockHandler', () => {
       })
     })
 
+    it('normalizes the persisted workspace-picker shape before provider execution', async () => {
+      const key = 'workspace/ws-1/example.png'
+      const hydrationSpy = vi
+        .spyOn(userFileBase64, 'hydrateUserFilesWithBase64')
+        .mockImplementationOnce(async (files) =>
+          files.map((file) => ({ ...file, base64: 'aW1hZ2U=' }))
+        )
+
+      try {
+        mockGetProviderFromModel.mockReturnValue('openai')
+
+        await handler.execute(mockContext, mockBlock, {
+          model: 'gpt-4o',
+          userPrompt: 'Analyze this file',
+          files: [
+            {
+              name: 'example.png',
+              path: `/api/files/serve/${encodeURIComponent(key)}?context=workspace`,
+              key,
+              size: 128,
+              type: 'image/png',
+            },
+          ],
+          apiKey: 'test-api-key',
+        })
+
+        const normalizedFile = hydrationSpy.mock.calls[0][0][0]
+        expect(normalizedFile).toMatchObject({
+          id: expect.stringMatching(/^file-\d+$/),
+          key,
+          name: 'example.png',
+          type: 'image/png',
+        })
+        expect(mockExecuteProviderRequest.mock.calls[0][1].messages.at(-1)?.files).toEqual([
+          expect.objectContaining({ key, name: 'example.png', base64: 'aW1hZ2U=' }),
+        ])
+      } finally {
+        hydrationSpy.mockRestore()
+      }
+    })
+
     it('should reject files for providers without attachment support', async () => {
       const inputs = {
         model: 'deepseek-chat',

apps/sim/lib/copilot/request/lifecycle/run.test.ts

@@ -496,14 +496,10 @@ describe('runCopilotLifecycle', () => {
     expect(JSON.parse(capturedRequestBody).fileAttachments).toEqual([safe])
   })
 
-  it('continues without attachments when durable provenance cannot be verified', async () => {
+  it('rejects when durable attachment provenance cannot be verified', async () => {
     mockFilterModelSafeWorkspaceFileAttachments.mockRejectedValueOnce(new Error('db unavailable'))
-    let capturedRequestBody = ''
-    mockRunStreamLoop.mockImplementationOnce(async (_url: string, request: RequestInit) => {
-      capturedRequestBody = String(request.body)
-    })
 
-    await runCopilotLifecycle(
+    const result = await runCopilotLifecycle(
       {
         message: 'Continue safely',
         fileAttachments: [{ id: 'wf-file', name: 'file.txt', key: 'workspace/ws-1/file.txt' }],
@@ -517,7 +513,11 @@ describe('runCopilotLifecycle', () => {
       }
     )
 
-    expect(JSON.parse(capturedRequestBody)).not.toHaveProperty('fileAttachments')
+    expect(result).toMatchObject({
+      success: false,
+      error: 'Copilot model input could not be safely projected',
+    })
+    expect(mockRunStreamLoop).not.toHaveBeenCalled()
   })
 
   it.each(['123', 'true'])(

apps/sim/lib/copilot/request/lifecycle/run.ts

@@ -607,11 +607,11 @@ async function omitUnsafeInitialCopilotAttachments(
     try {
       safeAttachments = await filterModelSafeWorkspaceFileAttachments(attachments, { workspaceId })
     } catch (error) {
-      logger.warn('Workspace file secret provenance could not be verified; omitting attachments', {
+      logger.error('Workspace file secret provenance could not be verified', {
         attachmentCount: attachments.length,
         error: toError(error).message,
       })
-      safeAttachments = []
+      throw new CopilotModelContentProjectionError()
     }
 
     if (safeAttachments.length === attachments.length) continue

apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts

@@ -141,12 +141,7 @@ describe('trackChatUpload', () => {
         displayName: 'image.png',
       })
     )
-    expect(mockReplaceWorkspaceFileSecretProvenanceInTx).toHaveBeenCalledWith(
-      expect.anything(),
-      'wf_existing',
-      CONTENT_UPDATED_AT,
-      { status: 'exact', entries: [] }
-    )
+    expect(mockReplaceWorkspaceFileSecretProvenanceInTx).not.toHaveBeenCalled()
     expectNoWorkspaceStorageAccounting()
   })
 
@@ -173,16 +168,11 @@ describe('trackChatUpload', () => {
         displayName: 'image.png',
       })
     )
-    expect(mockReplaceWorkspaceFileSecretProvenanceInTx).toHaveBeenCalledWith(
-      expect.anything(),
-      'wf_inserted',
-      CONTENT_UPDATED_AT,
-      { status: 'exact', entries: [] }
-    )
+    expect(mockReplaceWorkspaceFileSecretProvenanceInTx).not.toHaveBeenCalled()
     expectNoWorkspaceStorageAccounting()
   })
 
-  it('fails the chat binding transaction when provenance classification fails', async () => {
+  it('does not reclassify uploaded bytes while linking chat metadata', async () => {
     queueOwnershipLookup([existingRow()])
     dbChainMockFns.returning.mockResolvedValueOnce([
       { id: 'wf_existing', contentUpdatedAt: CONTENT_UPDATED_AT },
@@ -193,9 +183,10 @@ describe('trackChatUpload', () => {
 
     await expect(
       trackChatUpload(WORKSPACE_ID, USER_ID, CHAT_ID, S3_KEY, 'image.png', 'image/png', 1024)
-    ).rejects.toThrow('provenance write failed')
+    ).resolves.toEqual({ displayName: 'image.png' })
 
     expect(dbChainMockFns.transaction).toHaveBeenCalledTimes(1)
+    expect(mockReplaceWorkspaceFileSecretProvenanceInTx).not.toHaveBeenCalled()
   })
 
   it('stamps message_id on the UPDATE arm when the birth message is known', async () => {

apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts

@@ -727,6 +727,9 @@ async function resolveClaimableChatUploadRow(
  * Allocates a collision-free `displayName` (the partial unique index on
  * (chat_id, display_name) WHERE context='mothership' enforces this) and returns it
  * so callers can surface the same name to the model in the VFS read hint.
+ * This is a metadata-only operation: it preserves any content provenance already
+ * attached to the uploaded bytes. Direct user uploads use the established
+ * exact-empty/legacy classification and do not need a chat-time reclassification.
  */
 export async function trackChatUpload(
   workspaceId: string,
@@ -793,10 +796,7 @@ export async function trackChatUpload(
                 or(isNull(workspaceFiles.chatId), eq(workspaceFiles.chatId, chatId))
               )
             )
-            .returning({
-              id: workspaceFiles.id,
-              contentUpdatedAt: workspaceFiles.contentUpdatedAt,
-            })
+            .returning({ id: workspaceFiles.id })
 
           if (updated.length === 0) {
             // The ownership lookup is a separate statement, so re-assert every
@@ -807,13 +807,6 @@ export async function trackChatUpload(
             // to the chat-delete cascade.
             throw new WorkspaceFileKeyOwnershipError(s3Key)
           }
-
-          await replaceWorkspaceFileSecretProvenanceInTx(
-            tx,
-            updated[0].id,
-            updated[0].contentUpdatedAt,
-            EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE
-          )
         })
 
         logger.info(
@@ -840,20 +833,11 @@ export async function trackChatUpload(
             contentType,
             size,
           })
-          .returning({
-            id: workspaceFiles.id,
-            contentUpdatedAt: workspaceFiles.contentUpdatedAt,
-          })
+          .returning({ id: workspaceFiles.id })
 
         if (!inserted) {
           throw new Error(`Failed to track chat upload for key: ${s3Key}`)
         }
-        await replaceWorkspaceFileSecretProvenanceInTx(
-          tx,
-          inserted.id,
-          inserted.contentUpdatedAt,
-          EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE
-        )
       })
 
       logger.info(`Tracked chat upload: ${fileName} (display: ${candidate}) for chat ${chatId}`)

apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.test.ts

@@ -93,6 +93,36 @@ describe('workspace file secret provenance', () => {
     ).rejects.toThrow('could not bind the tracked content version')
   })
 
+  it('binds the database content version within its JavaScript-visible millisecond', async () => {
+    await replaceWorkspaceFileSecretProvenanceInTx(
+      dbChainMock.db as unknown as DbTransaction,
+      'file-1',
+      CONTENT_UPDATED_AT,
+      { status: 'exact', entries: [] }
+    )
+
+    expect(dbChainMockFns.where.mock.calls.at(-1)?.[0]).toEqual({
+      type: 'and',
+      conditions: [
+        { type: 'eq', left: 'id', right: 'file-1' },
+        { type: 'gte', left: 'contentUpdatedAt', right: CONTENT_UPDATED_AT },
+        {
+          type: 'lt',
+          left: 'contentUpdatedAt',
+          right: new Date(CONTENT_UPDATED_AT.getTime() + 1),
+        },
+        { type: 'inArray', column: 'context', values: ['workspace', 'mothership'] },
+        {
+          type: 'or',
+          conditions: [
+            { type: 'isNull', column: 'secretProvenanceVersion' },
+            { type: 'eq', left: 'secretProvenanceVersion', right: 1 },
+          ],
+        },
+      ],
+    })
+  })
+
   it('preserves provenance only from the exact preceding content version', async () => {
     const nextContentUpdatedAt = new Date('2026-08-04T00:00:01.000Z')
     queueTableRows(workspaceFileSecretProvenance, [{ contentUpdatedAt: CONTENT_UPDATED_AT }])

apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.ts

@@ -4,7 +4,7 @@ import {
   workspaceFileSecretProvenance,
   workspaceFiles,
 } from '@sim/db/schema'
-import { and, eq, inArray, isNull, or } from 'drizzle-orm'
+import { and, eq, gte, inArray, isNull, lt, or } from 'drizzle-orm'
 import type { DbTransaction } from '@/lib/db/types'
 import { importDurableSecretProvenance } from '@/lib/execution/durable-secret-provenance'
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
@@ -167,13 +167,15 @@ async function markWorkspaceFileSecretProvenanceTrackedInTx(
   fileId: string,
   contentUpdatedAt: Date
 ): Promise<void> {
+  const nextContentMillisecond = new Date(contentUpdatedAt.getTime() + 1)
   const [tracked] = await tx
     .update(workspaceFiles)
     .set({ secretProvenanceVersion: 1 })
     .where(
       and(
         eq(workspaceFiles.id, fileId),
-        eq(workspaceFiles.contentUpdatedAt, contentUpdatedAt),
+        gte(workspaceFiles.contentUpdatedAt, contentUpdatedAt),
+        lt(workspaceFiles.contentUpdatedAt, nextContentMillisecond),
         inArray(workspaceFiles.context, ['workspace', 'mothership']),
         or(
           isNull(workspaceFiles.secretProvenanceVersion),

apps/sim/providers/index.test.ts

@@ -832,37 +832,35 @@ describe('executeProviderRequest — model secret projection', () => {
     expect(mockExecuteRequest.mock.calls[0][0].messages[0].files).toEqual([safe])
   })
 
-  it('continues text-only when file provenance lookup is unavailable', async () => {
+  it('fails explicitly when file provenance lookup is unavailable', async () => {
     mockFilterModelSafeWorkspaceFileAttachments.mockRejectedValueOnce(new Error('db unavailable'))
 
-    await executeProviderRequest('openai', {
-      model: 'test-model',
-      workspaceId: 'ws-1',
-      messages: [
-        {
-          role: 'user',
-          content: 'Continue without the file',
-          files: [
-            {
-              id: 'wf-file',
-              name: 'file.txt',
-              url: '/file',
-              size: 10,
-              type: 'text/plain',
-              key: 'workspace/ws-1/file.txt',
-            },
-          ],
-        },
-      ],
-    })
-
-    expect(mockExecuteRequest).toHaveBeenCalledWith(
-      expect.objectContaining({
+    await expect(
+      executeProviderRequest('openai', {
+        model: 'test-model',
+        workspaceId: 'ws-1',
         messages: [
-          expect.objectContaining({ content: 'Continue without the file', files: undefined }),
+          {
+            role: 'user',
+            content: 'Review the file',
+            files: [
+              {
+                id: 'wf-file',
+                name: 'file.txt',
+                url: '/file',
+                size: 10,
+                type: 'text/plain',
+                key: 'workspace/ws-1/file.txt',
+              },
+            ],
+          },
         ],
       })
-    )
+    ).rejects.toThrow('File attachments could not be verified for model use')
+
+    expect(mockAttachLargeFileRemoteUrls).not.toHaveBeenCalled()
+    expect(mockUploadLargeFilesToProvider).not.toHaveBeenCalled()
+    expect(mockExecuteRequest).not.toHaveBeenCalled()
   })
 
   it('projects JSON arguments without mutating attachment metadata before serialization', async () => {

apps/sim/providers/index.ts

@@ -298,11 +298,11 @@ async function omitUnsafeProviderFileAttachments(
       workspaceId: request.workspaceId,
     })
   } catch (error) {
-    logger.warn('Workspace file secret provenance could not be verified; omitting attachments', {
+    logger.error('Workspace file secret provenance could not be verified', {
       attachmentCount: attachments.length,
       error: toError(error).message,
     })
-    safeAttachments = []
+    throw new Error('File attachments could not be verified for model use')
   }
 
   if (safeAttachments.length === attachments.length) return request