fix(connectors): keep resolved option labels and survive a half-failed key lookup

Addresses three review findings.

A key lookup failed entirely when either status leg errored, discarding a match
the other leg had found. Only a total failure is fatal now.

Resolved option labels are remembered for the lifetime of the field. Both lookups
key on values that change — the search box clears on select and close, and a
multi-select field resolves no id at all — so the label for a just-picked option
vanished a debounce later and the trigger fell back to a raw id. This covers the
multi-select case, which is what the Confluence space field uses.

A failed exact-value lookup now reads differently from a failed list load, rather
than being reported as "still loading" or "none found".

Author: waleedlatif1

apps/sim/app/api/tools/confluence/selector-spaces/route.ts

@@ -167,14 +167,15 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           new URLSearchParams({ keys: spaceKey, limit: String(PAGE_LIMIT), status: 'archived' })
         ),
       ])
-      if (!current.ok) return current.response
-      if (!archived.ok) return archived.response
+      // Only a total failure is fatal: one leg erroring must not discard a match
+      // the other leg found.
+      if (!current.ok && !archived.ok) return current.response
 
       // A single resolution, never a page in a drained stream, so no cursor.
       return NextResponse.json({
         spaces: [
-          ...toSpaces(current.data.results, 'current'),
-          ...toSpaces(archived.data.results, 'archived'),
+          ...(current.ok ? toSpaces(current.data.results, 'current') : []),
+          ...(archived.ok ? toSpaces(archived.data.results, 'archived') : []),
         ],
         nextCursor: undefined,
       })

apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/connector-selector-field/connector-selector-field.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useMemo, useState } from 'react'
+import { useEffect, useMemo, useState } from 'react'
 import { ChipCombobox, type ComboboxOption, Loader } from '@sim/emcn'
 import { SEARCH_DEBOUNCE_MS } from '@/lib/url-state'
 import { SELECTOR_CONTEXT_FIELDS } from '@/lib/workflows/subblocks/context'
@@ -10,7 +10,7 @@ import type {
 } from '@/app/workspace/[workspaceId]/knowledge/[id]/hooks/use-connector-config-fields'
 import { getDependsOnFields } from '@/blocks/utils'
 import type { ConnectorConfigField } from '@/connectors/types'
-import type { SelectorContext, SelectorKey } from '@/hooks/selectors/types'
+import type { SelectorContext, SelectorKey, SelectorOption } from '@/hooks/selectors/types'
 import { useSelectorOptionDetail, useSelectorOptions } from '@/hooks/selectors/use-selector-query'
 import { useDebounce } from '@/hooks/use-debounce'
 
@@ -77,54 +77,72 @@ export function ConnectorSelectorField({
     enabled: isEnabled,
   })
 
-  const emptyMessage = getEmptyMessage(field.title.toLowerCase(), {
-    error,
-    hasMore,
-    isFetchingMore,
-    truncated,
-  })
-
   /**
    * The option list fills by draining pages in the background and the combobox
    * filters it client-side, so an option is only findable once its page has
    * arrived. Resolving the typed value directly makes an exact id/key selectable
    * immediately, independent of drain progress. Debounced so typing does not
-   * issue a request per keystroke; selectors without a `fetchById` simply
-   * resolve nothing.
+   * issue a request per keystroke; selectors without a `fetchById` resolve nothing.
    */
   const debouncedSearch = useDebounce(searchTerm.trim(), SEARCH_DEBOUNCE_MS)
-  const { data: searchedOption } = useSelectorOptionDetail(field.selectorKey, {
+  const { data: searchedOption, error: searchError } = useSelectorOptionDetail(field.selectorKey, {
     context,
     detailId: isEnabled && debouncedSearch.length > 0 ? debouncedSearch : undefined,
   })
 
   /**
-   * Resolve the *selected* value too, not just the typed one. Selecting resets the
-   * search box, which drops `searchedOption` a debounce later, and the drain may
-   * not reach that option's page for tens of seconds — never, when truncated — so
-   * the trigger would fall back to the placeholder for a value just picked.
-   * Mirrors `SelectorCombobox` in the workflow editor. Multi-select is not covered:
-   * resolving N ids needs N hooks, so a multi value beyond the drain still renders
-   * as its raw id.
+   * Resolve the *selected* value too, not just the typed one, so the trigger does
+   * not fall back to a raw id for something just picked. Single-select only:
+   * resolving N ids would need N hooks, so multi-select relies on the remembered
+   * options below.
    */
   const singleValue = Array.isArray(value) ? value[0] : value
   const { data: selectedOption } = useSelectorOptionDetail(field.selectorKey, {
     context,
     detailId: !isMulti && isEnabled && singleValue ? singleValue : undefined,
   })
 
+  const emptyMessage = getEmptyMessage(field.title.toLowerCase(), {
+    error,
+    lookupFailed: Boolean(searchError),
+    hasMore,
+    isFetchingMore,
+    truncated,
+  })
+
+  /**
+   * Resolved options are remembered for the lifetime of the field. Both lookups are
+   * keyed on values that change — the search box clears on select and close, and a
+   * multi-select field resolves no id at all (that would need one hook per id) — so
+   * reading them directly would drop a label moments after it appeared, leaving the
+   * trigger showing a raw id for something the user just picked.
+   */
+  const [resolvedOptions, setResolvedOptions] = useState<Record<string, string>>({})
+  useEffect(() => {
+    const found = [searchedOption, selectedOption].filter(Boolean) as SelectorOption[]
+    if (found.length === 0) return
+    setResolvedOptions((prev) => {
+      let next = prev
+      for (const option of found) {
+        if (next[option.id] === option.label) continue
+        if (next === prev) next = { ...prev }
+        next[option.id] = option.label
+      }
+      return next
+    })
+  }, [searchedOption, selectedOption])
+
   const comboboxOptions = useMemo<ComboboxOption[]>(() => {
     const base = options.map((opt) => ({ label: opt.label, value: opt.id }))
     const seen = new Set(base.map((opt) => opt.value))
     const extras: ComboboxOption[] = []
-    for (const extra of [searchedOption, selectedOption]) {
-      if (extra && !seen.has(extra.id)) {
-        seen.add(extra.id)
-        extras.push({ label: extra.label, value: extra.id })
-      }
+    for (const [id, label] of Object.entries(resolvedOptions)) {
+      if (seen.has(id)) continue
+      seen.add(id)
+      extras.push({ label, value: id })
     }
     return extras.length > 0 ? [...extras, ...base] : base
-  }, [options, searchedOption, selectedOption])
+  }, [options, resolvedOptions])
 
   if (isLoading && isEnabled) {
     return (
@@ -190,11 +208,19 @@ export function ConnectorSelectorField({
  */
 function getEmptyMessage(
   noun: string,
-  state: { error: Error | null; hasMore: boolean; isFetchingMore: boolean; truncated: boolean }
+  state: {
+    error: Error | null
+    lookupFailed: boolean
+    hasMore: boolean
+    isFetchingMore: boolean
+    truncated: boolean
+  }
 ): string {
   // `field.title` is singular on some connectors ("Base") and plural on others
   // ("Spaces"), so only the settled message puts the noun behind a quantifier.
   if (state.error) return 'No match — the list failed to load. Try reopening'
+  // Distinct from the list failing: the list is fine, resolving the typed value is not.
+  if (state.lookupFailed) return 'No match — could not check that exact value'
   if (state.hasMore || state.isFetchingMore) return 'No match yet — still loading…'
   if (state.truncated) return 'No match — too many to list. Try a more exact term'
   return `No ${noun} found`