address comments

Author: icecrasher321

apps/sim/app/api/files/parse/route.test.ts

@@ -445,6 +445,43 @@ describe('File Parse API Route', () => {
     expect(inputValidationMockFns.mockSecureFetchWithPinnedIP).toHaveBeenCalledTimes(1)
   })
 
+  it('should include successful multi-file parse results when a later file exceeds the cap', async () => {
+    inputValidationMockFns.mockValidateUrlWithDNS.mockResolvedValue({
+      isValid: true,
+      resolvedIP: '203.0.113.10',
+    })
+    inputValidationMockFns.mockSecureFetchWithPinnedIP.mockResolvedValue(
+      new Response('file content', {
+        status: 200,
+        headers: { 'content-type': 'text/plain' },
+      })
+    )
+
+    mockParseBuffer
+      .mockResolvedValueOnce({
+        content: 'first file',
+        metadata: { pageCount: 1 },
+      })
+      .mockResolvedValueOnce({
+        content: 'a'.repeat(5 * 1024 * 1024),
+        metadata: { pageCount: 1 },
+      })
+
+    const req = createMockRequest('POST', {
+      filePath: ['https://example.com/file1.txt', 'https://example.com/file2.txt'],
+    })
+
+    const response = await POST(req)
+    const data = await response.json()
+
+    expect(response.status).toBe(413)
+    expect(data.success).toBe(false)
+    expect(data.error).toContain('too large')
+    expect(data.results).toHaveLength(1)
+    expect(data.results[0].output.content).toBe('first file')
+    expect(inputValidationMockFns.mockSecureFetchWithPinnedIP).toHaveBeenCalledTimes(2)
+  })
+
   it('should pass custom headers when fetching external URLs', async () => {
     inputValidationMockFns.mockValidateUrlWithDNS.mockResolvedValue({
       isValid: true,

apps/sim/app/api/files/parse/route.ts

@@ -162,7 +162,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
         const remainingOutputBytes = MAX_MULTI_FILE_PARSE_OUTPUT_BYTES - totalOutputBytes
         if (remainingOutputBytes <= 0) {
-          return parsedOutputTooLargeResponse()
+          return parsedOutputTooLargeResponse(results)
         }
 
         const result = await parseFileSingle(
@@ -183,7 +183,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         if (result.success) {
           totalOutputBytes += getContentBytes(result.content)
           if (totalOutputBytes > MAX_MULTI_FILE_PARSE_OUTPUT_BYTES) {
-            return parsedOutputTooLargeResponse()
+            return parsedOutputTooLargeResponse(results)
           }
 
           const displayName =
@@ -205,7 +205,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         }
 
         if (result.error?.startsWith('Parsed file output is too large')) {
-          return parsedOutputTooLargeResponse()
+          return parsedOutputTooLargeResponse(results)
         }
 
         results.push(result)
@@ -396,13 +396,14 @@ function validateFileReferenceShape(filePath: string): { isValid: boolean; error
   return { isValid: true }
 }
 
-function parsedOutputTooLargeResponse(): NextResponse {
+function parsedOutputTooLargeResponse(results?: unknown[]): NextResponse {
   return NextResponse.json(
     {
       success: false,
       error: `Parsed file output is too large to return safely. Maximum combined parsed output is ${prettySize(
         MAX_MULTI_FILE_PARSE_OUTPUT_BYTES
       )}.`,
+      ...(results && results.length > 0 ? { results } : {}),
     },
     { status: 413 }
   )

apps/sim/lib/execution/payloads/store.test.ts

@@ -29,6 +29,11 @@ vi.mock('@/lib/uploads', () => ({
   },
 }))
 
+vi.mock('@/lib/uploads/core/storage-service', () => ({
+  uploadFile: mockUploadFile,
+  downloadFile: mockDownloadFile,
+}))
+
 vi.mock('@/app/api/files/authorization', () => ({
   verifyFileAccess: mockVerifyFileAccess,
 }))

apps/sim/tools/file/parser.test.ts

@@ -81,4 +81,37 @@ describe('fileParserTool', () => {
       },
     })
   })
+
+  it('preserves partial multi-file parse successes from an oversized response', async () => {
+    const result = await fileParserTool.transformResponse?.(
+      Response.json(
+        {
+          success: false,
+          error: 'Parsed file output is too large to return safely.',
+          results: [
+            {
+              success: true,
+              output: {
+                content: 'ok',
+                fileType: 'text/plain',
+                size: 2,
+                name: 'ok.txt',
+                binary: false,
+              },
+            },
+          ],
+        },
+        { status: 413 }
+      )
+    )
+
+    expect(result).toMatchObject({
+      success: true,
+      error: 'Parsed file output is too large to return safely.',
+      output: {
+        files: [{ name: 'ok.txt', content: 'ok' }],
+        combinedContent: 'ok',
+      },
+    })
+  })
 })

apps/sim/tools/file/parser.ts

@@ -89,17 +89,6 @@ const parseFileParserResponse = async (response: Response): Promise<FileParserOu
   const result: unknown = await response.json()
   logger.info('Response parsed successfully')
 
-  if (isRecord(result) && result.success === false) {
-    return {
-      success: false,
-      output: {
-        files: [],
-        combinedContent: '',
-      },
-      error: typeof result.error === 'string' ? result.error : 'Failed to parse file',
-    }
-  }
-
   // Handle multiple files response
   if (isRecord(result) && Array.isArray(result.results)) {
     logger.info('Processing multiple files response')
@@ -129,10 +118,7 @@ const parseFileParserResponse = async (response: Response): Promise<FileParserOu
       .filter((fileResult) => !(isRecord(fileResult) && fileResult.success === false))
       .map((fileResult) => normalizeFileParseResult(fileResult))
 
-    // Collect UserFile objects from results
-    const processedFiles: UserFile[] = fileResults
-      .filter((file): file is FileParseResult & { file: UserFile } => Boolean(file.file))
-      .map((file) => file.file)
+    const processedFiles = fileResults.flatMap((file) => (file.file ? [file.file] : []))
 
     // Combine all file contents with clear dividers
     const combinedContent = fileResults
@@ -149,10 +135,23 @@ const parseFileParserResponse = async (response: Response): Promise<FileParserOu
       combinedContent,
       ...(processedFiles.length > 0 && { processedFiles }),
     }
+    const error = typeof result.error === 'string' ? result.error : undefined
 
     return {
       success: true,
       output,
+      ...(error ? { error } : {}),
+    }
+  }
+
+  if (isRecord(result) && result.success === false) {
+    return {
+      success: false,
+      output: {
+        files: [],
+        combinedContent: '',
+      },
+      error: typeof result.error === 'string' ? result.error : 'Failed to parse file',
     }
   }