fix(copilot): mount chat uploads in code sandboxes

Resolve uploads through the current chat, enforce workspace ownership, and reuse the existing URL or buffered sandbox mount path so function_execute and run_code can process uploaded files directly.

Author: j15z

apps/sim/lib/copilot/tools/handlers/function-execute.test.ts

@@ -18,6 +18,7 @@ const {
   mockFetchWorkspaceFileBuffer,
   mockGetSandboxWorkspaceFilePath,
   mockListWorkspaceFileFolders,
+  mockResolveChatUpload,
 } = vi.hoisted(() => ({
   mockIsFeatureEnabled: vi.fn(),
   mockGetTableById: vi.fn(),
@@ -33,6 +34,7 @@ const {
   mockFetchWorkspaceFileBuffer: vi.fn(),
   mockGetSandboxWorkspaceFilePath: vi.fn(),
   mockListWorkspaceFileFolders: vi.fn(),
+  mockResolveChatUpload: vi.fn(),
 }))
 
 vi.mock('@/lib/core/config/feature-flags', () => ({ isFeatureEnabled: mockIsFeatureEnabled }))
@@ -71,6 +73,9 @@ vi.mock('@/lib/copilot/vfs/workflow-aliases', () => ({
   isPlanAliasPath: () => false,
   workflowAliasSandboxPath: (p: string) => p,
 }))
+vi.mock('@/lib/copilot/tools/handlers/upload-file-reader', () => ({
+  resolveChatUpload: mockResolveChatUpload,
+}))
 
 import { executeFunctionExecute } from '@/lib/copilot/tools/handlers/function-execute'
 
@@ -268,6 +273,14 @@ const fileRecord = {
   storageContext: 'workspace' as const,
 }
 
+const uploadRecord = {
+  ...fileRecord,
+  id: 'upload_1',
+  name: 'My Report.csv',
+  key: 'mothership/chat_1/my-report.csv',
+  storageContext: 'mothership' as const,
+}
+
 describe('executeFunctionExecute file mounts', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -309,6 +322,51 @@ describe('executeFunctionExecute file mounts', () => {
     expect(file.type).toBeUndefined()
   })
 
+  it('mounts a chat upload at its canonical sandbox path', async () => {
+    mockResolveChatUpload.mockResolvedValue(uploadRecord)
+
+    await executeFunctionExecute({ inputs: { files: [{ path: 'uploads/My%20Report.csv' }] } }, {
+      ...context,
+      chatId: 'chat_1',
+    } as never)
+
+    expect(mockResolveChatUpload).toHaveBeenCalledWith('My%20Report.csv', 'chat_1')
+    expect(mockListWorkspaceFiles).not.toHaveBeenCalled()
+    expect(mockGeneratePresignedDownloadUrl).toHaveBeenCalledWith(
+      'mothership/chat_1/my-report.csv',
+      'mothership',
+      expect.any(Number)
+    )
+    expect(mountedFiles()[0]).toEqual({
+      type: 'url',
+      path: '/home/user/uploads/My%20Report.csv',
+      url: 'https://s3.example/file?sig=abc',
+    })
+  })
+
+  it('reports when a chat upload is no longer available', async () => {
+    mockResolveChatUpload.mockResolvedValue(null)
+
+    await expect(
+      executeFunctionExecute({ inputFiles: ['uploads/missing.csv'] }, {
+        ...context,
+        chatId: 'chat_1',
+      } as never)
+    ).rejects.toThrow('Upload not found: "uploads/missing.csv"')
+  })
+
+  it('rejects a chat upload from another workspace', async () => {
+    mockResolveChatUpload.mockResolvedValue({ ...uploadRecord, workspaceId: 'ws_2' })
+
+    await expect(
+      executeFunctionExecute({ inputFiles: ['uploads/My%20Report.csv'] }, {
+        ...context,
+        chatId: 'chat_1',
+      } as never)
+    ).rejects.toThrow('Upload does not belong to the current workspace')
+    expect(mockGeneratePresignedDownloadUrl).not.toHaveBeenCalled()
+  })
+
   it('cloud storage: throws when a file exceeds the per-file URL mount limit', async () => {
     mockFindWorkspaceFileRecord.mockReturnValue({ ...fileRecord, size: 600 * 1024 * 1024 })
 

apps/sim/lib/copilot/tools/handlers/function-execute.ts

@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { resolveChatUpload } from '@/lib/copilot/tools/handlers/upload-file-reader'
 import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/copilot/vfs/path-utils'
 import { resolveWorkflowAliasForWorkspace } from '@/lib/copilot/vfs/workflow-alias-resolver'
 import { isPlanAliasPath, workflowAliasSandboxPath } from '@/lib/copilot/vfs/workflow-aliases'
@@ -29,6 +30,7 @@ const logger = createLogger('CopilotFunctionExecute')
 const MAX_FILE_SIZE = 10 * 1024 * 1024
 const MAX_TOTAL_SIZE = 50 * 1024 * 1024
 const MAX_MOUNTED_FILES = 500
+const UPLOADS_PREFIX = 'uploads/'
 
 /**
  * Below this row count a table mounts via the direct inline CSV path — the version-keyed snapshot
@@ -170,7 +172,8 @@ export async function resolveInputFiles(
   workspaceId: string,
   inputFiles?: unknown[],
   inputTables?: unknown[],
-  inputDirectories?: unknown[]
+  inputDirectories?: unknown[],
+  chatId?: string
 ): Promise<SandboxFile[]> {
   const sandboxFiles: SandboxFile[] = []
   const mounted: MountedBytes = { buffered: 0, url: 0 }
@@ -182,9 +185,7 @@ export async function resolveInputFiles(
         `Too many input files (${inputFiles.length}). Maximum is ${MAX_MOUNTED_FILES}. Mount fewer files.`
       )
     }
-    const allFiles = await listWorkspaceFiles(workspaceId, {
-      includeReservedSystemFiles: betaEnabled,
-    })
+    let allFiles: WorkspaceFileRecord[] | undefined
     for (const fileRef of inputFiles) {
       const filePath =
         typeof fileRef === 'string'
@@ -193,6 +194,35 @@ export async function resolveInputFiles(
             ? (fileRef as CanonicalFileInput).path
             : undefined
       if (!filePath) continue
+      const explicitSandboxPath =
+        typeof fileRef === 'object' && fileRef !== null
+          ? (fileRef as CanonicalFileInput).sandboxPath
+          : undefined
+      if (filePath.startsWith(UPLOADS_PREFIX)) {
+        const fileName = filePath.slice(UPLOADS_PREFIX.length)
+        if (!fileName || fileName.includes('/')) {
+          throw new Error(`Upload input path must identify one file: "${filePath}"`)
+        }
+        if (!chatId) {
+          throw new Error(`Chat context is required to mount upload: "${filePath}"`)
+        }
+        const record = await resolveChatUpload(fileName, chatId)
+        if (!record) {
+          throw new Error(
+            `Upload not found: "${filePath}". The chat or upload may no longer exist.`
+          )
+        }
+        if (record.workspaceId !== workspaceId) {
+          throw new Error(`Upload does not belong to the current workspace: "${filePath}"`)
+        }
+        await pushWorkspaceFileMount(
+          sandboxFiles,
+          record,
+          explicitSandboxPath || `/home/user/${filePath}`,
+          mounted
+        )
+        continue
+      }
       const alias = await resolveWorkflowAliasForWorkspace({ workspaceId, path: filePath })
       if (!alias && isPlanAliasPath(filePath)) {
         logger.warn('Unsupported plan alias input file path', { filePath })
@@ -202,21 +232,15 @@ export async function resolveInputFiles(
         logger.warn('Input file is a plan alias directory', { filePath })
         continue
       }
+      allFiles ??= await listWorkspaceFiles(workspaceId, {
+        includeReservedSystemFiles: betaEnabled,
+      })
       const record = findWorkspaceFileRecord(allFiles, alias?.backingPath ?? filePath)
       if (!record) {
-        if (filePath.startsWith('uploads/')) {
-          throw new Error(
-            `Cannot mount "${filePath}": uploads/ files are not mountable into the sandbox. Use materialize_file to save it to a files/... path first, then mount that canonical path.`
-          )
-        }
         throw new Error(
           `Input file not found: "${filePath}". Pass the exact canonical VFS path copied from glob/read (e.g. "files/Reports/data.csv").`
         )
       }
-      const explicitSandboxPath =
-        typeof fileRef === 'object' && fileRef !== null
-          ? (fileRef as CanonicalFileInput).sandboxPath
-          : undefined
       const mountPath =
         explicitSandboxPath ||
         (alias ? workflowAliasSandboxPath(alias.aliasPath) : getSandboxWorkspaceFilePath(record))
@@ -441,7 +465,8 @@ export async function executeFunctionExecute(
         context.workspaceId,
         inputFiles,
         inputTables,
-        inputDirectories
+        inputDirectories,
+        context.chatId
       )
       if (resolved.length > 0) {
         const existing = (enrichedParams._sandboxFiles as SandboxFile[]) || []