fix(knowledge): guard every parser against empty output, not just the file parsers

Moving connector parsing into the pipeline exposed a gap on the OCR branch. OCR
reads a scanned page with no recoverable text as empty, and the empty-content
guard lived inside the file-parser path, so such a document chunked to nothing
and reported success — the same silently-complete-but-useless outcome the guard
exists to prevent. The check now sits above the parser choice and covers OCR
too.

Also preserves a source file's extension when its name is too long for a storage
key. The extension is what picks the parser; a truncated name would still parse
correctly by falling back to the display name, but only by luck.

Author: waleedlatif1

apps/sim/lib/knowledge/connectors/sync-engine.ts

@@ -65,6 +65,28 @@ function sanitizeStorageTitle(title: string): string {
   return title.replace(/[^a-zA-Z0-9.-]/g, '_').slice(0, MAX_SAFE_TITLE_LENGTH)
 }
 
+/**
+ * Sanitizes a source file's name for a storage key, keeping its extension.
+ *
+ * `sanitizeStorageTitle` truncates a long title outright, which for a source file
+ * would cut the extension off the end — and the extension is what
+ * `resolveStoredArtifactExtension` reads to pick a parser. Such a document would
+ * still parse correctly by falling back to its display name, but only by luck;
+ * preserving the suffix keeps the storage key authoritative for every file rather
+ * than for most of them.
+ */
+function sanitizeStorageFileName(fileName: string): string {
+  const dotIndex = fileName.lastIndexOf('.')
+  if (dotIndex <= 0) return sanitizeStorageTitle(fileName)
+
+  const extension = sanitizeStorageTitle(fileName.slice(dotIndex))
+  const base = sanitizeStorageTitle(fileName.slice(0, dotIndex)).slice(
+    0,
+    Math.max(1, MAX_SAFE_TITLE_LENGTH - extension.length)
+  )
+  return base + extension
+}
+
 /**
  * The bytes to store for a connector document, together with the name and type
  * that describe them.
@@ -85,7 +107,7 @@ function connectorStoredArtifact(extDoc: ExternalDocument): {
   if (extDoc.sourceFile) {
     return {
       bytes: extDoc.sourceFile.bytes,
-      fileName: sanitizeStorageTitle(extDoc.sourceFile.fileName),
+      fileName: sanitizeStorageFileName(extDoc.sourceFile.fileName),
       mimeType: extDoc.sourceFile.mimeType,
     }
   }

apps/sim/lib/knowledge/documents/document-processor.ts

@@ -206,6 +206,16 @@ export async function processDocument(
     const { content, processingMethod } = parseResult
     const cloudUrl = 'cloudUrl' in parseResult ? parseResult.cloudUrl : undefined
 
+    /**
+     * Guards every parser, not just the file parsers: OCR reads a scanned page
+     * that has no recoverable text as empty, and chunking empty content yields a
+     * document that reports success while holding nothing. Failing here keeps it
+     * visible with a reason instead.
+     */
+    if (parseResult.metadata?.degraded || !content.trim()) {
+      throw new Error(unreadableDocumentMessage(filename))
+    }
+
     let chunks: Chunk[]
     const metadata: FileParseMetadata = parseResult.metadata ?? {}
 
@@ -831,10 +841,6 @@ async function parseWithFileParser(
       )
     }
 
-    if (metadata.degraded || !content.trim()) {
-      throw new Error(unreadableDocumentMessage(filename))
-    }
-
     return { content, processingMethod: 'file-parser' as const, cloudUrl: undefined, metadata }
   } catch (error) {
     logger.error('File parser failed', { errorType: toError(error).name })

apps/sim/lib/knowledge/documents/unreadable-document.test.ts

@@ -52,6 +52,19 @@ describe('unreadable document handling', () => {
     await expect(parse('Scan.pdf')).rejects.toThrow(/scanned, image-only, or password-protected/)
   })
 
+  /**
+   * OCR reads a scanned page with no recoverable text as empty. Chunking that
+   * yields a document reporting success while holding nothing — the same silent
+   * failure the file-parser guard exists to prevent, so it has to cover OCR too.
+   */
+  it('fails an OCR result that came back empty', async () => {
+    mockParseBuffer.mockResolvedValue({ content: '', metadata: {} })
+
+    await expect(parse('Scanned.pdf', 'application/pdf')).rejects.toThrow(
+      /No text could be extracted/
+    )
+  })
+
   it('accepts a real extraction', async () => {
     mockParseBuffer.mockResolvedValue({
       content: 'Approved vendor list',