fix(files): preserve valid zero-byte tool outputs

Author: Bill Leoutsakos

apps/sim/executor/utils/file-tool-processor.test.ts

@@ -109,4 +109,80 @@ describe('FileToolProcessor', () => {
 
     expect(mockUploadExecutionFile).not.toHaveBeenCalled()
   })
+
+  it.each([Buffer.alloc(0), '', { type: 'Buffer', data: [] }])(
+    'stores valid zero-byte inline files as UserFile outputs: %j',
+    async (data) => {
+      const storedFile = {
+        id: 'empty-file',
+        key: 'workspace/workspace-1/empty-file',
+        name: 'empty.txt',
+        size: 0,
+        type: 'text/plain',
+        url: '/api/files/serve?key=workspace%2Fworkspace-1%2Fempty-file',
+      } satisfies UserFile
+      mockUploadExecutionFile.mockResolvedValue(storedFile)
+
+      const result = await FileToolProcessor.processToolOutputs(
+        {
+          file: {
+            name: 'empty.txt',
+            mimeType: 'text/plain',
+            data,
+            url: 'https://example.com/file',
+          },
+        },
+        toolConfig,
+        executionContext
+      )
+
+      expect(result.file).toEqual(storedFile)
+      expect(mockUploadExecutionFile).toHaveBeenCalledWith(
+        expect.objectContaining({ workspaceId: 'workspace-1', executionId: 'execution-1' }),
+        Buffer.alloc(0),
+        'empty.txt',
+        'text/plain',
+        'user-1'
+      )
+      expect(mockDownloadFileFromUrl).not.toHaveBeenCalled()
+    }
+  )
+
+  it('preserves empty file entries in file-array outputs', async () => {
+    const result = await FileToolProcessor.processToolOutputs(
+      { file: [{ name: 'empty.txt', mimeType: 'text/plain', data: '' }] },
+      { ...toolConfig, outputs: { file: { type: 'file[]' } } },
+      executionContext
+    )
+
+    expect(result.file).toHaveLength(1)
+    expect(mockUploadExecutionFile.mock.calls[0]?.[1]).toEqual(Buffer.alloc(0))
+  })
+
+  it('stores a successful zero-byte URL download', async () => {
+    mockDownloadFileFromUrl.mockResolvedValue(Buffer.alloc(0))
+
+    await FileToolProcessor.processToolOutputs(
+      { file: { name: 'empty.txt', mimeType: 'text/plain', url: 'https://example.com/empty' } },
+      toolConfig,
+      executionContext
+    )
+
+    expect(mockUploadExecutionFile.mock.calls[0]?.[1]).toEqual(Buffer.alloc(0))
+  })
+
+  it.each([undefined, null, '!!!', { type: 'Buffer', data: 'invalid' }])(
+    'does not turn missing or malformed data into an empty file: %j',
+    async (data) => {
+      await expect(
+        FileToolProcessor.processToolOutputs(
+          { file: { name: 'invalid.txt', mimeType: 'text/plain', data } },
+          toolConfig,
+          executionContext
+        )
+      ).rejects.toThrow("Failed to process file output 'file'")
+
+      expect(mockUploadExecutionFile).not.toHaveBeenCalled()
+    }
+  )
 })

apps/sim/executor/utils/file-tool-processor.ts

@@ -169,7 +169,7 @@ export class FileToolProcessor {
         } else {
           throw new Error(`Invalid serialized buffer format for ${data.name}`)
         }
-      } else if (typeof data.data === 'string' && data.data) {
+      } else if (typeof data.data === 'string') {
         let base64Data = data.data
 
         if (base64Data.includes('-') || base64Data.includes('_')) {
@@ -179,6 +179,9 @@ export class FileToolProcessor {
         const paddingBytes = base64Data.endsWith('==') ? 2 : base64Data.endsWith('=') ? 1 : 0
         assertFileSize(Math.floor((base64Data.length * 3) / 4) - paddingBytes, data.name)
         buffer = Buffer.from(base64Data, 'base64')
+        if (base64Data.length > 0 && buffer.length === 0) {
+          throw new Error(`File '${data.name}' has invalid base64 data`)
+        }
       }
 
       if (!buffer && data.url) {
@@ -189,9 +192,6 @@ export class FileToolProcessor {
       }
 
       if (buffer) {
-        if (buffer.length === 0) {
-          throw new Error(`File '${data.name}' has zero bytes`)
-        }
         assertFileSize(buffer.length, data.name)
         const storedMetadata = resolveStoredFileMetadata(data.name, data.mimeType, buffer)