fix(knowledge): carry the MIME type through hydration

A listing stub is built before the file is fetched and declares `text/plain` for
everything, so a hydrated PDF kept claiming plain text at the top level. Nothing
broke today only because storage reads `sourceFile.mimeType` — which is exactly
what makes it a trap: anything later reaching for `extDoc.mimeType`, the obvious
field, silently loses the OCR routing this change exists to restore.

The merge is now `mergeHydratedDocument` rather than an inline spread, so what
hydration must carry is a stated contract with a test behind it instead of a
literal that is easy to under-specify — which is how the field was missed.

Author: waleedlatif1

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

@@ -7,8 +7,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   classifySuspectListing,
   evaluateListingSafety,
+  mergeHydratedDocument,
   type PreviousListingObservation,
 } from '@/lib/knowledge/connectors/sync-engine'
+import type { ExternalDocument } from '@/connectors/types'
 
 vi.mock('drizzle-orm', () => ({
   and: vi.fn(),
@@ -627,3 +629,76 @@ describe('evaluateListingSafety', () => {
     })
   })
 })
+
+describe('mergeHydratedDocument', () => {
+  const stub = (): ExternalDocument => ({
+    externalId: 'file-1',
+    title: 'Report.pdf',
+    content: '',
+    mimeType: 'text/plain',
+    contentHash: 'sharepoint:file-1:v1',
+    contentDeferred: true,
+    metadata: { fileSize: 2_400_000 },
+  })
+
+  /**
+   * A stub is built during listing, before the file is fetched, so it declares
+   * `text/plain` for everything. Leaving that behind makes a hydrated PDF keep
+   * claiming plain text — invisible while storage reads `sourceFile.mimeType`,
+   * and a trap for anything that reaches for the obvious field instead.
+   */
+  it('carries the hydrated MIME type over the stub placeholder', () => {
+    const merged = mergeHydratedDocument(
+      stub(),
+      {
+        ...stub(),
+        content: '',
+        mimeType: 'application/pdf',
+        sourceFile: {
+          bytes: Buffer.from('%PDF'),
+          fileName: 'Report.pdf',
+          mimeType: 'application/pdf',
+        },
+      },
+      'sharepoint:file-1:v2'
+    )
+
+    expect(merged.mimeType).toBe('application/pdf')
+    expect(merged.sourceFile?.mimeType).toBe('application/pdf')
+  })
+
+  it('carries the source file and clears the deferred flag', () => {
+    const merged = mergeHydratedDocument(
+      stub(),
+      { ...stub(), sourceFile: { bytes: Buffer.from('x'), fileName: 'a.pdf', mimeType: 'a/b' } },
+      'h'
+    )
+
+    expect(merged.sourceFile?.bytes.toString()).toBe('x')
+    expect(merged.contentDeferred).toBe(false)
+    expect(merged.contentHash).toBe('h')
+  })
+
+  it('keeps text-path content and merges metadata over the stub', () => {
+    const merged = mergeHydratedDocument(
+      stub(),
+      { ...stub(), content: 'plain notes', metadata: { createdBy: 'A' } },
+      'h'
+    )
+
+    expect(merged.content).toBe('plain notes')
+    expect(merged.sourceFile).toBeUndefined()
+    expect(merged.metadata).toEqual({ fileSize: 2_400_000, createdBy: 'A' })
+  })
+
+  it('falls back to the stub title and sourceUrl when hydration omits them', () => {
+    const merged = mergeHydratedDocument(
+      { ...stub(), sourceUrl: 'https://example.com/a' },
+      { ...stub(), title: '', content: 'x' },
+      'h'
+    )
+
+    expect(merged.title).toBe('Report.pdf')
+    expect(merged.sourceUrl).toBe('https://example.com/a')
+  })
+})

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

@@ -172,6 +172,37 @@ export function classifyExternalDoc(
   return { type: 'unchanged' }
 }
 
+/**
+ * Merges a hydrated document over the listing stub it was fetched for.
+ *
+ * Every field the connector restates on hydration has to be carried, not just the
+ * content. A stub is built before the file is fetched and declares `text/plain`,
+ * so any field left behind keeps a value that is wrong for the bytes now attached
+ * — which is how a hydrated PDF ends up still claiming plain text. Storage reads
+ * `sourceFile.mimeType`, so that particular staleness is invisible until
+ * something reaches for the obvious field instead.
+ *
+ * Extracted from the hydration loop so the merge is a stated contract with a test
+ * rather than an inline spread that is easy to under-specify.
+ */
+export function mergeHydratedDocument(
+  stub: ExternalDocument,
+  hydrated: ExternalDocument,
+  contentHash: string
+): ExternalDocument {
+  return {
+    ...stub,
+    title: hydrated.title || stub.title,
+    content: hydrated.content,
+    sourceFile: hydrated.sourceFile,
+    mimeType: hydrated.mimeType,
+    contentHash,
+    contentDeferred: false,
+    sourceUrl: hydrated.sourceUrl ?? stub.sourceUrl,
+    metadata: { ...stub.metadata, ...hydrated.metadata },
+  }
+}
+
 /** Whether a document carries anything to index — extracted text or the source file. */
 function hasPayload(extDoc: Pick<ExternalDocument, 'content' | 'sourceFile'>): boolean {
   return extDoc.sourceFile !== undefined || extDoc.content.trim().length > 0
@@ -1087,19 +1118,7 @@ export async function executeSync(
               result.docsUnchanged++
               return null
             }
-            return {
-              ...op,
-              extDoc: {
-                ...op.extDoc,
-                title: fullDoc.title || op.extDoc.title,
-                content: fullDoc.content,
-                sourceFile: fullDoc.sourceFile,
-                contentHash: hydratedHash,
-                contentDeferred: false,
-                sourceUrl: fullDoc.sourceUrl ?? op.extDoc.sourceUrl,
-                metadata: { ...op.extDoc.metadata, ...fullDoc.metadata },
-              },
-            }
+            return { ...op, extDoc: mergeHydratedDocument(op.extDoc, fullDoc, hydratedHash) }
           })
         )