@sanity/assist 1.2.16 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/assist",
-  "version": "1.2.16",
-  "description": "",
+  "version": "2.0.0",
+  "description": "You create the instructions; Sanity AI Assist does the rest.",
   "keywords": [
     "sanity",
     "sanity-plugin",
@@ -54,10 +54,11 @@
     "release": "semantic-release"
   },
   "dependencies": {
-    "@sanity/icons": "^2.4.0",
+    "@sanity/icons": "^2.8.0",
     "@sanity/incompatible-plugin": "^1.0.4",
-    "@sanity/ui": "^2.0.0-beta.13",
+    "@sanity/ui": "^2.0.2",
     "date-fns": "^2.30.0",
+    "lodash.get": "^4.4.2",
     "react-fast-compare": "^3.2.1",
     "react-is": "^18.2.0",
     "rxjs": "^7.8.0",
@@ -72,8 +73,8 @@
     "@sanity/semantic-release-preset": "^4.1.6",
     "@types/react": "^18.2.37",
     "@types/styled-components": "^5.1.30",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.1",
+    "@typescript-eslint/parser": "^7.0.1",
     "date-fns": "^2.30.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^8.10.0",
@@ -85,15 +86,15 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rimraf": "^5.0.5",
-    "sanity": "^3.23.1",
+    "sanity": "^3.28.0",
     "semantic-release": "^21.1.2",
     "styled-components": "^6.1.1",
     "typescript": "^5.3.3",
-    "vitest": "^0.34.6"
+    "vitest": "^1.2.1"
   },
   "peerDependencies": {
     "react": "^18",
-    "sanity": "^3.16",
+    "sanity": "^3.26",
     "styled-components": "^5.2 || ^6.0.0"
   },
   "engines": {

package/src/_lib/form/DocumentForm.tsx

@@ -12,6 +12,7 @@ import {
   useDocumentStore,
 } from 'sanity'
 import {useDocumentPane} from 'sanity/desk'
+import {assistFormId} from './constants'
 
 const preventDefault = (ev: React.FormEvent) => ev.preventDefault()
 
@@ -135,7 +136,7 @@ export function DocumentForm(
             changed={formState.changed}
             focused={formState.focused}
             groups={formState.groups}
-            id="root"
+            id={assistFormId}
             members={formState.members}
             onChange={onChange}
             onFieldGroupSelect={onSetActiveFieldGroup}

package/src/_lib/form/constants.ts

@@ -0,0 +1 @@
+export const assistFormId = 'assist'

package/src/assistDocument/AssistDocumentInput.tsx

@@ -1,4 +1,4 @@
-import {InputProps, ObjectInputProps} from 'sanity'
+import {InputProps, ObjectInputProps, ObjectSchemaType} from 'sanity'
 import {AssistDocumentContextProvider} from './AssistDocumentContextProvider'
 import {FirstAssistedPathProvider} from '../onboarding/FirstAssistedPathProvider'
 import {useInstructionToaster} from './hooks/useInstructionToaster'
@@ -7,9 +7,12 @@ import {useLayer} from '@sanity/ui'
 import {useDocumentPane} from 'sanity/desk'
 import {usePathKey} from '../helpers/misc'
 import {ConnectFromRegion} from '../_lib/connector'
+import {assistDocumentTypeName} from '../types'
+import {useMemo} from 'react'
+import {assistFormId} from '../_lib/form/constants'
 
 export function AssistDocumentInputWrapper(props: InputProps) {
-  if (!isType(props.schemaType, 'document') && props.id !== 'root') {
+  if (!isType(props.schemaType, 'document') && props.id !== 'root' && props.id !== assistFormId) {
     return <AssistInput {...props} />
   }
 
@@ -24,10 +27,27 @@ export function AssistDocumentInputWrapper(props: InputProps) {
 function AssistDocumentInput({documentId, ...props}: ObjectInputProps & {documentId: string}) {
   useInstructionToaster(documentId, props.schemaType)
 
+  const schemaType = useMemo(() => {
+    if (props.schemaType.name !== assistDocumentTypeName) {
+      return props.schemaType
+    }
+    return {
+      ...props.schemaType,
+      type: {
+        ...props.schemaType.type,
+        // compatability with i18nArrays plugin that requires this to be document
+        name: 'document',
+      },
+    } as ObjectSchemaType
+  }, [props.schemaType])
+
   return (
     <FirstAssistedPathProvider members={props.members}>
-      <AssistDocumentContextProvider schemaType={props.schemaType} documentId={documentId}>
-        {props.renderDefault(props)}
+      <AssistDocumentContextProvider schemaType={schemaType} documentId={documentId}>
+        {props.renderDefault({
+          ...props,
+          schemaType,
+        })}
       </AssistDocumentContextProvider>
     </FirstAssistedPathProvider>
   )

package/src/assistDocument/RequestRunInstructionProvider.tsx

@@ -1,13 +1,13 @@
 import {useRunInstruction} from '../assistLayout/RunInstructionProvider'
 import {useCallback, useEffect, useState} from 'react'
 import {ObjectSchemaType, PatchEvent, SanityDocument, unset} from 'sanity'
-import {RunInstructionArgs} from '../assistLayout/AssistLayout'
 import {publicId} from '../helpers/ids'
 
-export interface DocumentArgs {
+export interface DraftDelayedTaskArgs<T> {
   documentOnChange: (event: PatchEvent) => void
   // indicates if the document is a draft or liveEditable currently
   isDocAssistable: boolean
+  task: (args: T) => void
 }
 
 export function isDocAssistable(
@@ -23,28 +23,44 @@ export function getAssistableDocId(documentSchemaType: ObjectSchemaType, documen
   return documentSchemaType.liveEdit ? baseId : `drafts.${baseId}`
 }
 
-export function useRequestRunInstruction(args: DocumentArgs) {
-  const {documentOnChange, isDocAssistable} = args
-
+export function useRequestRunInstruction(args: {
+  documentOnChange: (event: PatchEvent) => void
+  // indicates if the document is a draft or liveEditable currently
+  isDocAssistable: boolean
+}) {
   const {runInstruction, instructionLoading} = useRunInstruction()
-  const [queuedTask, setQueuedTask] = useState<RunInstructionArgs | undefined>(undefined)
-
-  useEffect(() => {
-    if (queuedTask && isDocAssistable) {
-      runInstruction(queuedTask)
-      setQueuedTask(undefined)
-    }
-  }, [queuedTask, isDocAssistable, runInstruction])
+  const requestRunInstruction = useDraftDelayedTask({
+    ...args,
+    task: runInstruction,
+  })
 
   return {
     instructionLoading,
-    requestRunInstruction: useCallback(
-      (task: RunInstructionArgs) => {
-        // make a dummy edit: this will trigger the document/draft to be created
-        documentOnChange(PatchEvent.from([unset(['_force_document_creation'])]))
-        setQueuedTask(task)
-      },
-      [setQueuedTask, documentOnChange]
-    ),
+    requestRunInstruction,
   }
 }
+
+/**
+ * Ensures that the current document is a draft before running task
+ */
+export function useDraftDelayedTask<T>(args: DraftDelayedTaskArgs<T>) {
+  const {documentOnChange, isDocAssistable, task} = args
+
+  const [queuedArgs, setQueuedArgs] = useState<T | undefined>(undefined)
+
+  useEffect(() => {
+    if (queuedArgs && isDocAssistable) {
+      task(queuedArgs)
+      setQueuedArgs(undefined)
+    }
+  }, [queuedArgs, isDocAssistable, task])
+
+  return useCallback(
+    (taskArgs: T) => {
+      // make a dummy edit: this will trigger the document/draft to be created
+      documentOnChange(PatchEvent.from([unset(['_force_document_creation'])]))
+      setQueuedArgs(taskArgs)
+    },
+    [setQueuedArgs, documentOnChange]
+  )
+}

package/src/assistDocument/components/instruction/InstructionInput.tsx

@@ -8,14 +8,15 @@ export function InstructionInput(props: ObjectInputProps) {
     <Stack space={[4, 4, 4, 5]}>
       <NameField {...props} />
       <ShareField {...props} />
-      <PromptField {...props} />
+      <ObjectMember fieldName={'prompt'} {...props} />
+      <ObjectMember fieldName={'output'} {...props} />
     </Stack>
   )
 }
 
-function PromptField(props: ObjectInputProps) {
-  const promptMember = findFieldMember(props.members, 'prompt')
-  return promptMember ? <ObjectInputMember {...props} member={promptMember} /> : null
+function ObjectMember({fieldName, ...props}: ObjectInputProps & {fieldName: string}) {
+  const member = findFieldMember(props.members, fieldName)
+  return member ? <ObjectInputMember {...props} member={member} /> : null
 }
 
 const NONE: (FieldMember | FieldError)[] = []

package/src/assistDocument/components/instruction/InstructionOutputField.tsx

@@ -0,0 +1,45 @@
+import {
+  ArrayFieldProps,
+  ArraySchemaType,
+  isArrayOfObjectsSchemaType,
+  isObjectSchemaType,
+  ObjectSchemaType,
+} from 'sanity'
+import {useCallback, useContext, useState} from 'react'
+import {SelectedFieldContext} from '../SelectedFieldContext'
+
+export function InstructionOutputField(props: ArrayFieldProps) {
+  const {fieldSchema} = useContext(SelectedFieldContext) ?? {}
+
+  if (
+    !fieldSchema ||
+    !(isObjectSchemaType(fieldSchema) || isArrayOfObjectsSchemaType(fieldSchema))
+  ) {
+    return null
+  }
+
+  return (
+    <EnabledOutputField {...props} fieldSchema={fieldSchema}>
+      {props.children}
+    </EnabledOutputField>
+  )
+}
+
+function EnabledOutputField({
+  fieldSchema,
+  ...props
+}: ArrayFieldProps & {fieldSchema: ObjectSchemaType | ArraySchemaType<ObjectSchemaType>}) {
+  const [open, setOpen] = useState(!!props.value?.length)
+  const onExpand = useCallback(() => setOpen(true), [])
+  const onCollapse = useCallback(() => setOpen(false), [])
+
+  return props.renderDefault({
+    ...props,
+    collapsible: true,
+    onExpand,
+    onCollapse,
+    collapsed: !open,
+    level: 1,
+    title: isObjectSchemaType(fieldSchema) ? 'Allowed fields' : 'Allowed types',
+  })
+}

package/src/assistDocument/components/instruction/InstructionOutputInput.tsx

@@ -0,0 +1,205 @@
+import {
+  ArrayOfObjectsInputProps,
+  ArraySchemaType,
+  FormPatch,
+  insert,
+  isArrayOfObjectsSchemaType,
+  isObjectSchemaType,
+  ObjectSchemaType,
+  PatchEvent,
+  setIfMissing,
+  typed,
+  unset,
+} from 'sanity'
+import {useCallback, useContext, useEffect, useMemo} from 'react'
+import {SelectedFieldContext} from '../SelectedFieldContext'
+import {Card, Checkbox, Flex, Stack, Text} from '@sanity/ui'
+import {isType} from '../../../helpers/typeUtils'
+import {isAssistSupported} from '../../../helpers/assistSupported'
+import {OutputFieldItem, outputFieldTypeName, OutputTypeItem} from '../../../types'
+
+export function InstructionOutputInput(props: ArrayOfObjectsInputProps) {
+  const {fieldSchema} = useContext(SelectedFieldContext) ?? {}
+
+  if (!fieldSchema) {
+    return null
+  }
+
+  if (isObjectSchemaType(fieldSchema)) {
+    return <ObjectOutputInput {...props} fieldSchema={fieldSchema} />
+  }
+
+  if (isArrayOfObjectsSchemaType(fieldSchema)) {
+    return <ArrayOutputInput {...props} fieldSchema={fieldSchema} />
+  }
+  return null
+}
+
+function useEmptySelectAllValue(
+  value: (OutputTypeItem | OutputFieldItem)[],
+  allowedValues: {name: string}[],
+  onChange: (patch: FormPatch | FormPatch[] | PatchEvent) => void
+) {
+  useEffect(() => {
+    const validValues = value?.filter((v) =>
+      allowedValues.find(
+        (f) => f.name === (v._type === outputFieldTypeName ? v.relativePath : v.type)
+      )
+    )
+    const valueLength = value?.length ?? 0
+    const validLength = validValues?.length ?? 0
+    if ((!validLength && valueLength) || validLength >= allowedValues.length) {
+      // if we end up here, we consider this a "no selected fields/types" selections. This should render and behave as all values selected.
+      // we need this behaviour to accommodate new fields/types being added to the model, so they get visited by instructions without having to update the filter
+      // when things have been explicitly selected, we let the selection remain as is
+      onChange(PatchEvent.from([unset()]))
+    }
+  }, [allowedValues, value, onChange])
+}
+
+function ObjectOutputInput({
+  fieldSchema,
+  ...props
+}: ArrayOfObjectsInputProps & {fieldSchema: ObjectSchemaType}) {
+  const {value, onChange} = props
+
+  const fields = useMemo(
+    () => fieldSchema.fields.filter((field) => isAssistSupported(field.type)),
+    [fieldSchema.fields]
+  )
+
+  useEmptySelectAllValue(value as OutputTypeItem[], fields, onChange)
+
+  const onSelectChange = useCallback(
+    (checked: boolean, selectedValue: string) => {
+      if (checked) {
+        if (value?.length) {
+          onChange(PatchEvent.from(unset([{_key: selectedValue}])))
+        } else {
+          // we went from empty array to everything selected but one
+          const items = fields
+            .filter((f) => f.name !== selectedValue)
+            .map((field) =>
+              typed<OutputFieldItem>({
+                _key: field.name,
+                _type: 'sanity.assist.output.field',
+                relativePath: field.name,
+              })
+            )
+          onChange(PatchEvent.from([setIfMissing([]), insert(items, 'after', [-1])]))
+        }
+      } else {
+        const patchValue: OutputFieldItem = {
+          _key: selectedValue,
+          _type: 'sanity.assist.output.field',
+          relativePath: selectedValue,
+        }
+        onChange(PatchEvent.from([setIfMissing([]), insert([patchValue], 'after', [-1])]))
+      }
+    },
+    [onChange, value, fields]
+  )
+
+  return (
+    <Stack space={2}>
+      {fields.map((field) => {
+        return (
+          <Flex key={field.name} align="center" gap={2}>
+            <Selectable
+              value={field.name}
+              title={field.type.title ?? field.name}
+              arrayValue={value as OutputFieldItem[]}
+              onChange={onSelectChange}
+            />
+          </Flex>
+        )
+      })}
+    </Stack>
+  )
+}
+
+function ArrayOutputInput({
+  fieldSchema,
+  ...props
+}: ArrayOfObjectsInputProps & {fieldSchema: ArraySchemaType}) {
+  const {value, onChange} = props
+
+  const ofItems = useMemo(
+    () => fieldSchema.of.filter((itemType) => isAssistSupported(itemType)),
+    [fieldSchema.of]
+  )
+
+  useEmptySelectAllValue(value as OutputTypeItem[], ofItems, onChange)
+
+  const onSelectChange = useCallback(
+    (checked: boolean, selectedValue: string) => {
+      if (checked) {
+        if (value?.length) {
+          onChange(PatchEvent.from(unset([{_key: selectedValue}])))
+        } else {
+          // we went from empty array to everything selected but one
+          const items = ofItems
+            .filter((f) => f.name !== selectedValue)
+            .map((field) =>
+              typed<OutputTypeItem>({
+                _key: field.name,
+                _type: 'sanity.assist.output.type',
+                type: field.name,
+              })
+            )
+          onChange(PatchEvent.from([setIfMissing([]), insert(items, 'after', [-1])]))
+        }
+      } else {
+        const patchValue: OutputTypeItem = {
+          _key: selectedValue,
+          _type: 'sanity.assist.output.type',
+          type: selectedValue,
+        }
+        onChange(PatchEvent.from([setIfMissing([]), insert([patchValue], 'after', [-1])]))
+      }
+    },
+    [onChange, value, ofItems]
+  )
+  return (
+    <Stack space={2}>
+      {ofItems.map((itemType) => {
+        return (
+          <Flex key={itemType.name}>
+            <Selectable
+              value={itemType.name}
+              title={isType(itemType, 'block') ? 'Text' : itemType.title ?? itemType.name}
+              arrayValue={value as OutputTypeItem[] | undefined}
+              onChange={onSelectChange}
+            />
+          </Flex>
+        )
+      })}
+    </Stack>
+  )
+}
+
+function Selectable({
+  title,
+  arrayValue,
+  value,
+  onChange,
+}: {
+  title: string
+  value: string
+  arrayValue?: {_key: string}[]
+  onChange: (checked: boolean, value: string) => void
+}) {
+  const checked = !arrayValue?.length || !!arrayValue?.find((v) => v._key === value)
+  const handleChange = useCallback(() => onChange(checked, value), [onChange, checked, value])
+
+  return (
+    <Flex gap={2} align="flex-start">
+      <Checkbox checked={checked} onChange={handleChange} />
+      <Card marginTop={1} onClick={handleChange}>
+        <Text style={{cursor: 'default'}} size={1}>
+          {title}
+        </Text>
+      </Card>
+    </Flex>
+  )
+}

package/src/assistDocument/hooks/useStudioAssistDocument.ts

@@ -3,24 +3,14 @@ import {
   assistDocumentTypeName,
   AssistTasksStatus,
   assistTasksStatusTypeName,
-  FieldRef,
-  fieldReferenceTypeName,
   InstructionTask,
   StudioAssistDocument,
   StudioAssistField,
   StudioInstruction,
 } from '../../types'
-import {
-  ObjectSchemaType,
-  pathToString,
-  typed,
-  useClient,
-  useCurrentUser,
-  useValidationStatus,
-  ValidationMarker,
-} from 'sanity'
+import {ObjectSchemaType, typed, useClient, useCurrentUser} from 'sanity'
 import {useDocumentState} from './useDocumentState'
-import {assistDocumentId, assistTasksStatusId, publicId} from '../../helpers/ids'
+import {assistDocumentId, assistTasksStatusId} from '../../helpers/ids'
 import {maxHistoryVisibilityMs} from '../../constants'
 
 interface UseAssistDocumentProps {
@@ -37,7 +27,6 @@ export function useStudioAssistDocument({
   const documentTypeName = schemaType.name
   const currentUser = useCurrentUser()
 
-  const validation = useValidationStatus(publicId(documentId), schemaType.name).validation
   const assistDocument = useDocumentState<StudioAssistDocument>(
     assistDocumentId(documentTypeName),
     assistDocumentTypeName
@@ -73,7 +62,7 @@ export function useStudioAssistDocument({
         tasks: tasks.filter((task) => task.path === assistField.path),
         instructions: assistField.instructions
           ?.filter((p) => !p.userId || p.userId === currentUser?.id)
-          .map((instruction) => asStudioInstruction(instruction, tasks, validation)),
+          .map((instruction) => asStudioInstruction(instruction, tasks)),
       }
     })
     return typed<StudioAssistDocument>({
@@ -89,23 +78,13 @@ export function useStudioAssistDocument({
       }),
       fields: fields,
     })
-  }, [assistDocument, assistTasksStatus, currentUser, validation])
+  }, [assistDocument, assistTasksStatus, currentUser])
 }
 
 function asStudioInstruction(
   instruction: StudioInstruction,
-  run: InstructionTask[],
-  validation: ValidationMarker[]
+  run: InstructionTask[]
 ): StudioInstruction {
-  const errors = validation.filter((marker) => marker.level === 'error')
-
-  const fieldRefs: FieldRef[] = (instruction?.prompt ?? []).flatMap((block) => {
-    if (block._type === 'block') {
-      return block.children.filter((c): c is FieldRef => c._type === fieldReferenceTypeName)
-    }
-    return []
-  })
-
   return {
     ...instruction,
     tasks: run
@@ -115,11 +94,5 @@ function asStudioInstruction(
           task.started &&
           new Date().getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs
       ),
-    validation: errors.filter((marker) =>
-      fieldRefs
-        .map((r) => r.path)
-        .filter((p): p is string => !!p)
-        .find((path) => pathToString(marker.path) === path)
-    ),
   }
 }

package/src/assistFormComponents/AssistField.tsx

@@ -9,6 +9,7 @@ import {AiFieldPresence} from '../presence/AiFieldPresence'
 import {AssistOnboardingPopover} from '../onboarding/FieldActionsOnboarding'
 import {FirstAssistedPathContext} from '../onboarding/FirstAssistedPathProvider'
 import {fieldOnboardingKey, useOnboardingFeature} from '../onboarding/onboardingStore'
+import {assistFormId} from '../_lib/form/constants'
 
 export function AssistFieldWrapper(props: FieldProps) {
   const {schemaType} = props
@@ -22,7 +23,11 @@ export function AssistFieldWrapper(props: FieldProps) {
   ) {
     return props.renderDefault(props)
   }
-  if (!isType(props.schemaType, 'document') && props.inputId !== 'root') {
+  if (
+    !isType(props.schemaType, 'document') &&
+    props.inputId !== 'root' &&
+    props.inputId !== assistFormId
+  ) {
     return <AssistField {...props}>{props.children}</AssistField>
   }
 
@@ -46,14 +51,15 @@ export function AssistField(props: FieldProps) {
   )
 
   const {showOnboarding, dismissOnboarding} = useOnboardingFeature(fieldOnboardingKey)
+  const singlePresence = presence[0]
 
   const actions = (
     <Flex gap={2} align="center" justify="space-between">
-      {presence.map((pre) => (
-        <Box key={pre.user.id}>
-          <AiFieldPresence key={pre.lastActiveAt} presence={pre} />
+      {singlePresence && (
+        <Box>
+          <AiFieldPresence presence={singlePresence} />
         </Box>
-      ))}
+      )}
 
       {isFirstAssisted && showOnboarding && <AssistOnboardingPopover dismiss={dismissOnboarding} />}
     </Flex>

package/src/assistFormComponents/AssistFormBlock.tsx

@@ -18,13 +18,12 @@ export function AssistFormBlock(props: BlockProps) {
     },
     [onChange, key]
   )
+  const singlePresence = presence[0]
   return (
     <ErrorWrapper onChange={localOnChange}>
       <Flex align="center" justify="space-between">
         <Box flex={1}>{props.renderDefault(props)}</Box>
-        {presence.map((pre) => (
-          <AiFieldPresence key={pre.lastActiveAt} presence={pre} />
-        ))}
+        {singlePresence && <AiFieldPresence presence={singlePresence} />}
       </Flex>
     </ErrorWrapper>
   )

package/src/assistFormComponents/validation/listItem.tsx

@@ -47,9 +47,9 @@ export function ListItem(props: ValidationListItemProps) {
             {path}
           </StyledText>
         )}
-        {marker.item.message && (
+        {marker.item?.message && (
           <StyledText muted size={1} textOverflow={truncate ? 'ellipsis' : undefined}>
-            {marker.item.message}
+            {marker.item?.message}
           </StyledText>
         )}
       </Stack>

package/src/assistInspector/AssistInspector.tsx

@@ -31,6 +31,7 @@ import {InspectorOnboarding} from '../onboarding/InspectorOnboarding'
 import {inspectorOnboardingKey, useOnboardingFeature} from '../onboarding/onboardingStore'
 import {TypePathContext} from '../assistDocument/components/AssistDocumentForm'
 import {FieldTitle} from './FieldAutocomplete'
+import {getConditionalMembers} from '../helpers/conditionalMembers'
 
 const CardWithShadowBelow = styled(Card)`
   position: relative;
@@ -199,9 +200,13 @@ export function AssistInspector(props: DocumentInspectorProps) {
     value: docValue,
     schemaType,
     onChange: documentOnChange,
+    formState,
   } = documentPane
   const {published, draft} = useEditState(documentId, documentType, 'low')
 
+  const formStateRef = useRef(formState)
+  formStateRef.current = formState
+
   const assistableDocId = getAssistableDocId(schemaType, documentId)
   const {instructionLoading, requestRunInstruction} = useRequestRunInstruction({
     documentOnChange,
@@ -261,6 +266,7 @@ export function AssistInspector(props: DocumentInspectorProps) {
         typePath,
         assistDocumentId: assistDocumentId(documentType),
         instruction,
+        conditionalMembers: formStateRef.current ? getConditionalMembers(formStateRef.current) : [],
       }),
     [pathKey, instruction, typePath, documentType, assistableDocId, requestRunInstruction]
   )

package/src/assistInspector/FieldAutocomplete.tsx

@@ -32,6 +32,7 @@ export function FieldAutocomplete(props: FieldSelectorProps) {
     () =>
       fieldRefs
         .filter((field) => (filter ? filter(field) : true))
+        .filter((f) => !isType(f.schemaType, 'reference'))
         .map((field) => ({value: field.key, field})),
     [fieldRefs, filter]
   )