fix(files): preserve rendered attachment semantics

Author: j15z

apps/sim/lib/copilot/tools/server/files/doc-compile.ts

@@ -541,8 +541,12 @@ export async function resolveServableDocBytes(args: {
     }
   }
 
-  // Reaches here only for xlsx, which has no isolated-vm fallback.
-  if (!format) return { buffer: rawBuffer, contentType: getContentType(fileName) }
+  // Reaches here only for xlsx, which has no isolated-vm fallback. With workspace
+  // context, returning these bytes would expose generation source as a spreadsheet.
+  if (!format) {
+    if (workspaceId) throw new DocCompileUserError('Document is still being generated')
+    return { buffer: rawBuffer, contentType: getContentType(fileName) }
+  }
 
   const cacheKey = sha256Hex(`${ext}${source}${workspaceId ?? ''}`)
   const cached = compiledDocCache.get(cacheKey)

apps/sim/lib/copilot/tools/server/files/doc-servable.test.ts

@@ -158,6 +158,21 @@ describe('resolveServableDocBytes', () => {
     expect(mockRunSandboxTask).not.toHaveBeenCalled()
   })
 
+  it('throws instead of returning XLSX source when E2B is disabled', async () => {
+    mockLoadCompiledDoc.mockResolvedValue(null)
+    setEnvFlags({ isDocSandboxEnabled: false })
+
+    await expect(
+      resolveServableDocBytes({
+        rawBuffer: XLSX_SOURCE,
+        fileName: 'sheet.xlsx',
+        workspaceId: WORKSPACE_ID,
+      })
+    ).rejects.toBeInstanceOf(DocCompileUserError)
+
+    expect(mockRunSandboxTask).not.toHaveBeenCalled()
+  })
+
   it('returns raw XLSX source when there is no workspaceId (xlsx has no isolated-vm path)', async () => {
     const result = await resolveServableDocBytes({
       rawBuffer: XLSX_SOURCE,

apps/sim/lib/execution/payloads/materialization.server.test.ts

@@ -34,6 +34,7 @@ const generatedPdf: UserFile = {
 describe('readUserFileContent', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    generatedPdf.size = PDF_SOURCE.length
     mockVerifyFileAccess.mockResolvedValue(true)
     mockDownloadServableFileFromStorage.mockResolvedValue({
       buffer: PDF_BYTES,
@@ -50,5 +51,6 @@ describe('readUserFileContent', () => {
     expect(mockDownloadServableFileFromStorage).toHaveBeenCalledOnce()
     expect(content).toBe(PDF_BYTES.toString('base64'))
     expect(content).not.toBe(PDF_SOURCE.toString('base64'))
+    expect(generatedPdf.size).toBe(PDF_BYTES.length)
   })
 })

apps/sim/lib/execution/payloads/materialization.server.ts

@@ -10,7 +10,11 @@ import {
 } from '@/lib/execution/payloads/large-value-ref'
 import { ExecutionResourceLimitError } from '@/lib/execution/resource-errors'
 import type { StorageContext } from '@/lib/uploads'
-import { bufferToBase64, inferContextFromKey } from '@/lib/uploads/utils/file-utils'
+import {
+  bufferToBase64,
+  inferContextFromKey,
+  isGeneratedDocumentSourceType,
+} from '@/lib/uploads/utils/file-utils'
 import { downloadServableFileFromStorage } from '@/lib/uploads/utils/file-utils.server'
 import type { UserFile } from '@/executor/types'
 
@@ -267,6 +271,11 @@ export async function assertUserFileContentAccess(
   }
 }
 
+/**
+ * Reads the bytes a consumer should receive. For generated documents, updates the
+ * file's size to the rendered artifact size so downstream attachment routing does
+ * not make decisions from the smaller generation-source size.
+ */
 export async function readUserFileContent(
   file: unknown,
   options: ReadUserFileContentOptions
@@ -296,6 +305,9 @@ export async function readUserFileContent(
     ).buffer
   } catch (error) {
     if (isPayloadSizeLimitError(error)) {
+      if (isGeneratedDocumentSourceType(file.type) && error.observedBytes !== undefined) {
+        file.size = error.observedBytes
+      }
       throw new ExecutionResourceLimitError({
         resource: 'execution_payload_bytes',
         attemptedBytes: error.observedBytes ?? maxSourceBytes + 1,
@@ -308,6 +320,9 @@ export async function readUserFileContent(
   if (!buffer) {
     throw new Error(`File content for ${file.name} is unavailable.`)
   }
+  if (isGeneratedDocumentSourceType(file.type)) {
+    file.size = buffer.length
+  }
   if (buffer.length > maxSourceBytes) {
     throw new ExecutionResourceLimitError({
       resource: 'execution_payload_bytes',

apps/sim/lib/uploads/utils/user-file-base64.server.test.ts

@@ -108,6 +108,65 @@ describe('hydrateUserFilesWithBase64', () => {
     expect(hydrated.file.base64).toBe(base64)
   })
 
+  it('uses rendered size when generated source metadata exceeds the inline limit', async () => {
+    const rendered = Buffer.from('%PDF')
+    mockDownloadServableFileFromStorage.mockResolvedValueOnce({
+      buffer: rendered,
+      contentType: 'application/pdf',
+    })
+    const file: UserFile = {
+      id: 'file-1',
+      name: 'report.pdf',
+      key: 'workspace/2f1d8c3e-5b6a-4c7d-8e9f-0a1b2c3d4e5f/report.pdf',
+      url: '',
+      size: 11,
+      type: 'text/x-python-pdf',
+    }
+
+    const hydrated = await hydrateUserFilesWithBase64({ file }, { maxBytes: 10, userId: 'user-1' })
+
+    expect(hydrated.file.base64).toBe(rendered.toString('base64'))
+    expect(hydrated.file.size).toBe(rendered.length)
+  })
+
+  it('records rendered size when a generated document must use a provider upload path', async () => {
+    mockDownloadServableFileFromStorage.mockResolvedValueOnce({
+      buffer: Buffer.alloc(11),
+      contentType: 'application/pdf',
+    })
+    const file: UserFile = {
+      id: 'file-1',
+      name: 'report.pdf',
+      key: 'workspace/2f1d8c3e-5b6a-4c7d-8e9f-0a1b2c3d4e5f/report.pdf',
+      url: '',
+      size: 1,
+      type: 'text/x-python-pdf',
+    }
+
+    const hydrated = await hydrateUserFilesWithBase64({ file }, { maxBytes: 10, userId: 'user-1' })
+
+    expect(hydrated.file).not.toHaveProperty('base64')
+    expect(hydrated.file.size).toBe(11)
+  })
+
+  it('propagates generated documents that are still compiling', async () => {
+    const notReady = new Error('Document is still being generated')
+    notReady.name = 'DocCompileUserError'
+    mockDownloadServableFileFromStorage.mockRejectedValueOnce(notReady)
+    const file: UserFile = {
+      id: 'file-1',
+      name: 'report.pdf',
+      key: 'workspace/2f1d8c3e-5b6a-4c7d-8e9f-0a1b2c3d4e5f/report.pdf',
+      url: '',
+      size: 1,
+      type: 'text/x-python-pdf',
+    }
+
+    await expect(
+      hydrateUserFilesWithBase64({ file }, { maxBytes: 10, userId: 'user-1' })
+    ).rejects.toBe(notReady)
+  })
+
   it('does not hydrate URL-only internal file objects', async () => {
     const file: UserFile = {
       id: 'file-1',

apps/sim/lib/uploads/utils/user-file-base64.server.ts

@@ -27,6 +27,7 @@ import {
   ExecutionResourceLimitError,
   isExecutionResourceLimitError,
 } from '@/lib/execution/resource-errors'
+import { isGeneratedDocumentSourceType } from '@/lib/uploads/utils/file-utils'
 import type { UserFile } from '@/executor/types'
 
 const INLINE_BASE64_JSON_OVERHEAD_BYTES = 512 * 1024
@@ -391,7 +392,11 @@ async function resolveBase64(
   const allowUnknownSize = options.allowUnknownSize ?? false
   const hasStableStorageKey = Boolean(file.key)
 
-  if (Number.isFinite(file.size) && file.size > maxBytes) {
+  if (
+    !isGeneratedDocumentSourceType(file.type) &&
+    Number.isFinite(file.size) &&
+    file.size > maxBytes
+  ) {
     logger.warn(
       `[${options.requestId}] Skipping base64 for ${file.name} (size ${file.size} exceeds ${maxBytes})`
     )
@@ -420,9 +425,11 @@ async function resolveBase64(
       userId: options.userId,
       encoding: 'base64',
       maxBytes,
-      maxSourceBytes: maxBytes,
     })
   } catch (error) {
+    if (error instanceof Error && error.name === 'DocCompileUserError') {
+      throw error
+    }
     logger.warn(`[${requestId}] Failed to hydrate base64 for ${file.name}`, error)
     return null
   }

apps/sim/providers/attachments.test.ts

@@ -310,6 +310,16 @@ describe('provider large-file capability', () => {
     expect(shouldUseLargeFilePath(large, 'bedrock')).toBe(false)
   })
 
+  it('does not expose generated source through a remote-url large-file path', () => {
+    const generated = {
+      ...pdfFile,
+      size: INLINE_ATTACHMENT_THRESHOLD_BYTES + 1,
+      type: 'text/x-python-pdf',
+    }
+    expect(shouldUseLargeFilePath(generated, 'openai')).toBe(true)
+    expect(shouldUseLargeFilePath(generated, 'anthropic')).toBe(false)
+  })
+
   it('references uploaded OpenAI files by file_id instead of inlining base64', () => {
     const content = buildOpenAIMessageContent(
       'Analyze',

apps/sim/providers/attachments.ts

@@ -89,12 +89,18 @@ export function getProviderFileStrategy(providerId: ProviderId | string): Provid
   return getProviderFileAttachment(providerId).strategy
 }
 
-/** True when a file exceeds the inline threshold and the provider has a large-file path. */
+/**
+ * True when an oversized file has a safe provider path. Remote URLs point at the
+ * primary storage object, so source-backed documents can only use artifact-aware
+ * Files API uploads.
+ */
 export function shouldUseLargeFilePath(
-  file: Pick<UserFile, 'size'>,
+  file: Pick<UserFile, 'size' | 'type'>,
   providerId: ProviderId | string
 ): boolean {
-  if (getProviderFileAttachment(providerId).strategy === 'inline') return false
+  const strategy = getProviderFileAttachment(providerId).strategy
+  if (strategy === 'inline') return false
+  if (strategy === 'remote-url' && isGeneratedDocumentSourceType(file.type)) return false
   return Number.isFinite(file.size) && file.size > INLINE_ATTACHMENT_THRESHOLD_BYTES
 }