fix(connectors): act on the final validation sweep

Findings from a read-only /validate-connector pass over all 59 changed
connectors, verified against provider specs before acting.

Silent-drop fixes (a fulfilled null from getDocument records no failure and
no log, so the document vanishes):
- ashby: candidate.info returning success with an unusable payload. Ashby
  sets contentDeferred, so this path is live.
- azure-devops: an unresolvable branch, likewise live.
- dropbox: 409 covers the whole LookupError union, and restricted_content
  and locked both mean the file still exists. Only not_found is absence.
- docusign: fetchFormValues swallowed every non-OK status, baking a
  permanently incomplete document since the hash is metadata-only.

typeform: 'all' sent response_type=started,partial,completed, but Typeform
documents only partial and completed. An unknown enum member risks a 400
that fails the whole sync, and staging omitted the parameter entirely, so
this shipped as a regression. Now requests the widest documented set.

github: removes a utf-8 blob branch justified by a misattributed quote —
that sentence describes the encoding REQUEST parameter of Create a blob;
the GET response is documented as always base64. Also corrects two comments
that hid a real drop: >1 MB files under vnd.github+json 403 rather than
returning encoding: none.

hubspot: routes HTML detection through a shared anchored helper. The loose
pattern matched angle-bracketed prose such as an email address, and
htmlToPlainText deletes the span and collapses line structure. This matters
now because the hubspot:v2: bump rewrites every live document once.

youtube: drops an invented channel-ID format quote.

Author: waleedlatif1

apps/sim/connectors/ashby/ashby.ts

@@ -605,12 +605,24 @@ export const ashbyConnector: ConnectorConfig = {
     externalId: string
   ): Promise<ExternalDocument | null> => {
     try {
-      if (!externalId) return null
+      /**
+       * These are API-shape faults, not absence: `candidate.info` answered
+       * `success: true` with an unusable payload. Returning `null` would read as
+       * documented absence, and on an `add` the engine's `Promise.allSettled`
+       * hydration treats a fulfilled `null` as neither success nor failure — no
+       * `docsFailed`, no `failedExternalIds`, no log — so the candidate would
+       * vanish silently. Ashby sets `contentDeferred`, so this path is live.
+       */
+      if (!externalId) throw new Error('Ashby getDocument called without a candidate id')
 
       const infoData = await ashbyPost(accessToken, 'candidate.info', { id: externalId })
-      if (!infoData.results) return null
+      if (!infoData.results) {
+        throw new Error(`Ashby candidate.info returned no results for candidate ${externalId}`)
+      }
       const candidate = mapCandidate(infoData.results)
-      if (!candidate.id) return null
+      if (!candidate.id) {
+        throw new Error(`Ashby candidate.info returned a candidate with no id for ${externalId}`)
+      }
 
       const notes = await fetchAllNotes(accessToken, candidate.id)
 

apps/sim/connectors/azure-devops/azure-devops.ts

@@ -1079,9 +1079,15 @@ async function getFileDocument(
     branchOverride,
     syncContext
   )
+  /**
+   * A branch that will not resolve is a lookup failure, not an absent file — the
+   * file only reached hydration because the listing already resolved its repo.
+   * Returning `null` reads as documented absence, and on an `add` the engine's
+   * `Promise.allSettled` hydration counts a fulfilled `null` as neither success
+   * nor failure, so the file would vanish with no `docsFailed` and no log.
+   */
   if (!branch) {
-    logger.warn('Cannot resolve branch for Azure DevOps file', { externalId })
-    return null
+    throw new Error(`Cannot resolve branch for Azure DevOps file ${externalId}`)
   }
 
   const metadataParams = new URLSearchParams({

apps/sim/connectors/docusign/docusign.ts

@@ -384,7 +384,17 @@ async function fetchFormValues(
         },
       }
     )
-    if (!response.ok) return []
+    /**
+     * Only a 404 means the envelope carries no form data. Swallowing every other
+     * status would bake a permanently incomplete document: `buildContentHash` is
+     * metadata-only, so the next sync computes the identical hash, classifies the
+     * document `unchanged`, and the missing form-data section is never recovered
+     * until the envelope's status changes again.
+     */
+    if (response.status === 404) return []
+    if (!response.ok) {
+      throw new Error(`Failed to fetch DocuSign form data: ${response.status}`)
+    }
     const data = (await response.json()) as DocuSignFormData
     const values: DocuSignFormValue[] = []
     if (Array.isArray(data.formData)) values.push(...data.formData)

apps/sim/connectors/dropbox/dropbox.ts

@@ -289,13 +289,22 @@ export const dropboxConnector: ConnectorConfig = {
     })
 
     /**
-     * Dropbox reports endpoint-specific errors — including `path/not_found` — as 409,
-     * the only status that means the file is genuinely gone. Every other failure
-     * (429, 5xx, network faults) propagates so the sync engine records a failed row
-     * and keeps the already-indexed file out of deletion reconciliation.
+     * Dropbox reports every endpoint-specific error as 409, so the status alone
+     * does not mean the file is gone. For `get_metadata` the error union is
+     * `path: LookupError`, whose variants include `restricted_content` and
+     * `locked` — the file still exists in both. Only `not_found` is absence, and
+     * only that returns `null`; anything else propagates so the sync engine
+     * records a failed row instead of silently dropping the document.
      */
     if (!response.ok) {
-      if (response.status === 409) return null
+      if (response.status === 409) {
+        const body = (await response.json().catch(() => null)) as {
+          error?: { '.tag'?: string; path?: { '.tag'?: string } }
+        } | null
+        if (body?.error?.['.tag'] === 'path' && body.error.path?.['.tag'] === 'not_found') {
+          return null
+        }
+      }
       throw new Error(`Failed to get metadata: ${response.status}`)
     }
 

apps/sim/connectors/github/github.ts

@@ -176,12 +176,14 @@ async function fetchBlobContent(
     return buf.toString('utf8')
   }
   /**
-   * https://docs.github.com/en/rest/git/blobs documents two encodings —
-   * "Currently, 'utf-8' and 'base64' are supported" — so a utf-8 body is already
-   * plain text and is used as written. Any other encoding would silently persist
-   * empty content, so it throws and surfaces as a failed document instead.
+   * `GET /repos/{owner}/{repo}/git/blobs/{sha}` documents a single response
+   * encoding: "The `content` in the response will always be Base64 encoded."
+   * The "Currently, `utf-8` and `base64` are supported" sentence belongs to the
+   * `encoding` REQUEST parameter of `POST .../git/blobs` (Create a blob) and does
+   * not describe this response, so no `utf-8` branch is warranted here. Any other
+   * encoding would silently persist empty content, so it throws and surfaces as a
+   * failed document instead.
    */
-  if (encoding === 'utf-8') return content
   throw new Error(`Unexpected git blob encoding for ${sha}: ${encoding ?? 'undefined'}`)
 }
 
@@ -334,8 +336,14 @@ export const githubConnector: ConnectorConfig = {
         /**
          * A rate-limit 403 never reaches here: `fetchWithRetry` treats a 403 carrying
          * `retry-after` or `x-ratelimit-remaining: 0` as retryable and throws once the
-         * retries are spent, so it lands in the catch below as a failure. A 403 that
-         * survives to this point is a genuine authorization denial.
+         * retries are spent, so it lands in the catch below as a failure.
+         *
+         * A 403 that survives is usually an authorization denial, but NOT always: this
+         * request sends `application/vnd.github+json`, and the Contents API documents
+         * that files between 1-100 MB support "only the `raw` or `object` custom media
+         * types". A >1 MB text file therefore also lands here and is dropped, which on
+         * an `add` is silent (a fulfilled `null` records no failure). Reconciliation is
+         * unaffected — the file is already in `seenExternalIds` from the listing.
          */
         if (response.status === 403) {
           logger.info('Skipping GitHub file rejected by Contents API', {
@@ -381,10 +389,16 @@ export const githubConnector: ConnectorConfig = {
       } else if (encoding === 'none' && data.sha && size > 0) {
         /**
          * Per https://docs.github.com/en/rest/repos/contents, for files of 1-100 MB
-         * "the content field will be an empty string and the encoding field will be
-         * `none`". The Contents page points at the raw media type; the Git Blobs API
-         * is used instead because it returns the same blob as JSON and is documented
-         * to support blobs up to 100 MB.
+         * "only the `raw` or `object` custom media types are supported", and it is
+         * specifically "when using the `object` media type" that "the `content` field
+         * will be an empty string and the `encoding` field will be `none`".
+         *
+         * This request sends `application/vnd.github+json`, so that precondition does
+         * not hold and this branch is currently unreachable — such files 403 above
+         * instead. Reaching it would require requesting
+         * `application/vnd.github.object+json`. The fallback itself is correct: the Git
+         * Blobs API returns the same blob as JSON and is documented to support blobs up
+         * to 100 MB.
          */
         const blobContent = await fetchBlobContent(accessToken, owner, repo, data.sha as string)
         if (blobContent === null) {

apps/sim/connectors/granola/granola.ts

@@ -3,7 +3,7 @@ import { getErrorMessage, toError } from '@sim/utils/errors'
 import { fetchWithRetry, VALIDATE_RETRY_OPTIONS } from '@/lib/knowledge/documents/utils'
 import { granolaConnectorMeta } from '@/connectors/granola/meta'
 import type { ConnectorConfig, ExternalDocument, ExternalDocumentList } from '@/connectors/types'
-import { htmlToPlainText, joinTagArray, parseTagDate } from '@/connectors/utils'
+import { htmlToPlainText, joinTagArray, looksLikeHtml, parseTagDate } from '@/connectors/utils'
 
 const logger = createLogger('GranolaConnector')
 
@@ -138,24 +138,6 @@ function parseDateFilter(sourceConfig: Record<string, unknown>, key: string): st
   return Number.isNaN(parsed.getTime()) ? undefined : parsed.toISOString()
 }
 
-/**
- * Matches a real HTML tag, anchored to a known tag name rather than any
- * `<word…>` run. Markdown autolinks (`<https://acme.com>`, `<jane@acme.com>`)
- * and angle-bracketed prose (`<redacted>`) are common in meeting summaries, and
- * a looser pattern would route the whole markdown document through
- * `htmlToPlainText`, which collapses every newline and destroys its structure.
- */
-const HTML_TAG_PATTERN =
-  /<\/?(?:p|div|br|hr|ul|ol|li|h[1-6]|table|thead|tbody|tr|td|th|span|strong|em|b|i|u|a|code|pre|blockquote|img|figure)\b[^>]*>/i
-
-/**
- * Detects HTML markup in a summary. Granola documents `summary_markdown` as
- * markdown, so this only guards against the API ever emitting HTML instead.
- */
-function looksLikeHtml(value: string): boolean {
-  return HTML_TAG_PATTERN.test(value)
-}
-
 /**
  * Assembles the document content from a note's title and summary. Prefers the
  * markdown summary, falling back to plain-text summary. HTML is stripped only

apps/sim/connectors/hubspot/hubspot.ts

@@ -3,7 +3,7 @@ import { getErrorMessage } from '@sim/utils/errors'
 import { fetchWithRetry, VALIDATE_RETRY_OPTIONS } from '@/lib/knowledge/documents/utils'
 import { hubspotConnectorMeta } from '@/connectors/hubspot/meta'
 import type { ConnectorConfig, ExternalDocument, ExternalDocumentList } from '@/connectors/types'
-import { htmlToPlainText, parseTagDate } from '@/connectors/utils'
+import { htmlToPlainText, looksLikeHtml, parseTagDate } from '@/connectors/utils'
 
 const logger = createLogger('HubSpotConnector')
 
@@ -177,9 +177,14 @@ function buildRecordTitle(objectType: string, properties: Record<string, string
 /**
  * HubSpot rich-text properties (ticket `content`, company `description`, custom
  * rich-text fields) come back as raw HTML, so they are stripped before indexing.
+ *
+ * The detection is deliberately the shared anchored one: CRM free text regularly
+ * carries angle brackets that are not markup (`Reply from John <john@acme.com>`),
+ * and a false positive here does not pass the value through — `htmlToPlainText`
+ * would delete the bracketed span and collapse the value's line structure.
  */
 function toPlainTextValue(value: string): string {
-  return /<[a-z!/][^>]*>/i.test(value) ? htmlToPlainText(value) : value
+  return looksLikeHtml(value) ? htmlToPlainText(value) : value
 }
 
 /**

apps/sim/connectors/typeform/meta.ts

@@ -39,7 +39,7 @@ export const typeformConnectorMeta: ConnectorMeta = {
       options: [
         { label: 'Completed only', id: 'completed' },
         { label: 'Partial & completed', id: 'partial' },
-        { label: 'All (started, partial & completed)', id: 'all' },
+        { label: 'All available (partial & completed)', id: 'all' },
       ],
       description: 'Which responses to sync by completion status. Defaults to completed only.',
     },

apps/sim/connectors/typeform/typeform.test.ts

@@ -55,12 +55,17 @@ describe('typeform listDocuments', () => {
     expect(requestUrl(1).searchParams.get('response_type')).toBe('completed')
   })
 
-  it('requests all three response types for the "all" choice', async () => {
+  /**
+   * Typeform documents only `partial` and `completed` as `response_type` members,
+   * so `all` must not send an undocumented `started`: an unknown enum member risks
+   * a 400 that fails the entire sync.
+   */
+  it('requests only the documented response types for the "all" choice', async () => {
     mockFormThenResponses({ items: [] })
 
     await typeformConnector.listDocuments(ACCESS_TOKEN, { ...FORM_CONFIG, responseType: 'all' })
 
-    expect(requestUrl(1).searchParams.get('response_type')).toBe('started,partial,completed')
+    expect(requestUrl(1).searchParams.get('response_type')).toBe('partial,completed')
   })
 
   it('derives an incremental since filter at the second precision the API documents', async () => {

apps/sim/connectors/typeform/typeform.ts

@@ -124,16 +124,22 @@ function getResponseTypeChoice(sourceConfig: Record<string, unknown>): ResponseT
 /**
  * Appends the `response_type` filter for a given choice. Omitting the parameter
  * would fall back to the API default of `completed` only, so every choice is sent
- * explicitly. `partial` requests both partial and completed so partially-answered
- * submissions are included alongside finished ones; `all` additionally requests
- * `started`, the third response type (the documented `sort` default names all
- * three: `submitted_at` for completed, `staged_at` for partial, `landed_at` for
- * started).
+ * explicitly.
+ *
+ * Typeform documents exactly two members: "It is expected to be passed as a comma
+ * separated list of values, e.g. `response_type=partial,completed`", defaulting to
+ * `completed`. There is no documented `started` member — the `sort` docs imply a
+ * started *state* exists (ordering falls back to `landed_at`), but that does not
+ * make it a valid filter value, and sending an undocumented member risks a 400
+ * that fails the entire sync. `all` therefore requests the widest documented set,
+ * which is the same as `partial`.
  */
 function appendResponseType(params: URLSearchParams, choice: ResponseTypeChoice): void {
-  if (choice === 'partial') params.append('response_type', 'partial,completed')
-  else if (choice === 'all') params.append('response_type', 'started,partial,completed')
-  else params.append('response_type', 'completed')
+  if (choice === 'partial' || choice === 'all') {
+    params.append('response_type', 'partial,completed')
+  } else {
+    params.append('response_type', 'completed')
+  }
 }
 
 /**