@sanity/assist 1.1.4 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "",
   "keywords": [
     "sanity",
@@ -81,7 +81,7 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rimraf": "^4.4.0",
-    "sanity": "^3.16.1",
+    "sanity": "^3.16.7",
     "semantic-release": "^21.0.5",
     "styled-components": "^5.3.9",
     "typescript": "^5.1.3",

package/src/assistDocument/components/AssistDocumentForm.tsx

@@ -1,13 +1,13 @@
 import {
+  AssistDocument,
+  AssistField,
   assistFieldTypeName,
   AssistInspectorRouteParams,
-  AssistDocument,
   documentRootKey,
   fieldPathParam,
-  AssistField,
   instructionParam,
 } from '../../types'
-import {useEffect, useMemo, useRef} from 'react'
+import {createContext, useContext, useEffect, useMemo, useRef} from 'react'
 import {
   FormCallbacksProvider,
   FormCallbacksValue,
@@ -33,6 +33,8 @@ import {documentTypeFromAiDocumentId} from '../../helpers/ids'
 
 const EMPTY_FIELDS: AssistField[] = []
 
+export const TypePathContext = createContext<string | undefined>(undefined)
+
 export function AssistDocumentForm(props: ObjectInputProps) {
   const {onChange} = props
   const value = props.value as AssistDocument | undefined
@@ -48,12 +50,15 @@ export function AssistDocumentForm(props: ObjectInputProps) {
 
   const {params, setParams} = useAiPaneRouter()
   const pathKey = params[fieldPathParam]
+  const typePath = useContext(TypePathContext)
   const instruction = params[instructionParam]
 
-  const activeKey = useMemo(
-    () => (fields ?? EMPTY_FIELDS).find((f) => f.path === pathKey)?._key,
-    [fields, pathKey]
-  )
+  const activeKey = useMemo(() => {
+    if (!typePath) {
+      return undefined
+    }
+    return (fields ?? EMPTY_FIELDS).find((f) => f.path === typePath)?._key
+  }, [fields, typePath])
 
   const activePath: Path | undefined = useMemo(() => {
     if (!activeKey) {
@@ -72,6 +77,7 @@ export function AssistDocumentForm(props: ObjectInputProps) {
   }, [schema, targetDocumentType])
 
   const fieldSchema = useSelectedSchema(pathKey, documentSchema)
+
   const context: SelectedFieldContextValue = useMemo(
     () => ({
       documentSchema,
@@ -88,7 +94,7 @@ export function AssistDocumentForm(props: ObjectInputProps) {
     }
   }, [title, documentSchema, onChange, id])
 
-  const fieldExists = !!fields?.some((f) => f._key === pathKey)
+  const fieldExists = !!fields?.some((f) => f._key === typePath)
 
   const {onPathOpen, ...formCallbacks} = useFormCallbacks()
 
@@ -122,8 +128,8 @@ export function AssistDocumentForm(props: ObjectInputProps) {
     <SelectedFieldContextProvider value={context}>
       <Stack space={5}>
         <FieldsInitializer
-          key={pathKey}
-          pathKey={pathKey}
+          key={typePath}
+          pathKey={typePath}
           activePath={activePath}
           fieldExists={fieldExists}
           onChange={onChange}

package/src/assistDocument/components/InstructionsArrayField.tsx

@@ -3,6 +3,6 @@ import {ArrayFieldProps} from 'sanity'
 export function InstructionsArrayField(props: ArrayFieldProps) {
   return props.renderDefault({
     ...props,
-    title: undefined,
+    title: ' ',
   })
 }

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

@@ -3,9 +3,12 @@ import {useCallback, useContext, useEffect, useId, useRef} from 'react'
 import {Box} from '@sanity/ui'
 import {SelectedFieldContext} from '../SelectedFieldContext'
 import {FieldAutocomplete} from '../../../assistInspector/FieldAutocomplete'
+import {FieldRef} from '../../../assistInspector/helpers'
+import {TypePathContext} from '../AssistDocumentForm'
 
 export function FieldRefPathInput(props: StringInputProps) {
   const documentSchema = useContext(SelectedFieldContext)?.documentSchema
+  const typePath = useContext(TypePathContext)
   const ref = useRef<HTMLDivElement>(null)
   const id = useId()
   const {onChange} = props
@@ -16,17 +19,29 @@ export function FieldRefPathInput(props: StringInputProps) {
 
   const onSelect = useCallback((path: string) => onChange(set(path)), [onChange])
 
+  const filter = useCallback(
+    (field: FieldRef) => {
+      if (!field.key.includes('|') || !typePath) {
+        return true
+      }
+      const dotSplit = typePath.split('.')
+      const base = dotSplit.slice(0, dotSplit.length - 1).join('.')
+      return field.key.includes(base)
+    },
+    [typePath]
+  )
   if (!documentSchema) {
     return props.renderDefault(props)
   }
 
   return (
-    <Box flex={1} style={{minWidth: 200}} ref={ref}>
+    <Box flex={1} style={{minWidth: 300}} ref={ref}>
       <FieldAutocomplete
         id={id}
         schemaType={documentSchema}
         onSelect={onSelect}
         fieldPath={props.value}
+        filter={filter}
       />
     </Box>
   )

package/src/assistInspector/AssistInspector.tsx

@@ -15,7 +15,7 @@ import {
 } from 'sanity/desk'
 import {DocumentForm} from '../_lib/form'
 import {assistDocumentTypeName, fieldPathParam, instructionParam} from '../types'
-import {getFieldTitle, useAiPaneRouter, useSelectedField} from './helpers'
+import {FieldRef, getFieldTitle, useAiPaneRouter, useSelectedField, useTypePath} from './helpers'
 import styled from 'styled-components'
 import {useStudioAssistDocument} from '../assistDocument/hooks/useStudioAssistDocument'
 import {InstructionTaskHistoryButton} from './InstructionTaskHistoryButton'
@@ -29,6 +29,8 @@ import {
 } from '../assistDocument/RequestRunInstructionProvider'
 import {InspectorOnboarding} from '../onboarding/InspectorOnboarding'
 import {inspectorOnboardingKey, useOnboardingFeature} from '../onboarding/onboardingStore'
+import {TypePathContext} from '../assistDocument/components/AssistDocumentForm'
+import {FieldTitle} from './FieldAutocomplete'
 
 const CardWithShadowBelow = styled(Card)`
   position: relative;
@@ -191,7 +193,13 @@ export function AssistInspector(props: DocumentInspectorProps) {
   const pathKey = params?.[fieldPathParam]
   const instructionKey = params?.[instructionParam]
   const documentPane = useDocumentPane()
-  const {documentId, documentType, schemaType, onChange: documentOnChange} = documentPane
+  const {
+    documentId,
+    documentType,
+    value: docValue,
+    schemaType,
+    onChange: documentOnChange,
+  } = documentPane
   const {published, draft} = useEditState(documentId, documentType, 'low')
 
   const assistableDocId = getAssistableDocId(schemaType, documentId)
@@ -199,12 +207,14 @@ export function AssistInspector(props: DocumentInspectorProps) {
     documentOnChange,
     isDocAssistable: isDocAssistable(schemaType, published, draft),
   })
-  const selectedField = useSelectedField(schemaType, params[fieldPathParam])
+
+  const typePath = useTypePath(docValue, pathKey ?? '')
+  const selectedField = useSelectedField(schemaType, typePath)
 
   const aiDocId = assistDocumentId(documentType)
 
   const assistDocument = useStudioAssistDocument({documentId, schemaType})
-  const assistField = assistDocument?.fields?.find((f) => f.path === pathKey)
+  const assistField = assistDocument?.fields?.find((f) => f.path === typePath)
   const instruction = assistField?.instructions?.find((i) => i._key === instructionKey)
   const tasks = useMemo(
     () =>
@@ -244,13 +254,15 @@ export function AssistInspector(props: DocumentInspectorProps) {
     () =>
       instruction &&
       pathKey &&
+      typePath &&
       requestRunInstruction({
         documentId: assistableDocId,
         path: pathKey,
+        typePath,
         assistDocumentId: assistDocumentId(documentType),
         instruction,
       }),
-    [instruction, pathKey, documentType, assistableDocId, requestRunInstruction]
+    [pathKey, instruction, typePath, documentType, assistableDocId, requestRunInstruction]
   )
 
   const Region = useCallback((_props: any) => {
@@ -282,7 +294,11 @@ export function AssistInspector(props: DocumentInspectorProps) {
       sizing="border"
       style={{lineHeight: 0}}
     >
-      <AiInspectorHeader onClose={props.onClose} fieldTitle={getFieldTitle(selectedField)} />
+      <AiInspectorHeader
+        onClose={props.onClose}
+        field={selectedField}
+        fieldTitle={getFieldTitle(selectedField)}
+      />
 
       <Card as={Region} flex={1} overflow="auto">
         <Flex direction="column" style={{minHeight: '100%'}}>
@@ -290,19 +306,21 @@ export function AssistInspector(props: DocumentInspectorProps) {
             <PresenceOverlay>
               <Box padding={4}>
                 {selectedField && (
-                  <VirtualizerScrollInstanceProvider
-                    scrollElement={boundary.current}
-                    containerElement={boundary}
-                  >
-                    <DocumentPaneProvider
-                      paneKey={documentPane.paneKey}
-                      index={documentPane.index}
-                      itemId="ai"
-                      pane={paneNode}
+                  <TypePathContext.Provider value={typePath}>
+                    <VirtualizerScrollInstanceProvider
+                      scrollElement={boundary.current}
+                      containerElement={boundary}
                     >
-                      <DocumentForm />
-                    </DocumentPaneProvider>
-                  </VirtualizerScrollInstanceProvider>
+                      <DocumentPaneProvider
+                        paneKey={documentPane.paneKey}
+                        index={documentPane.index}
+                        itemId="ai"
+                        pane={paneNode}
+                      >
+                        <DocumentForm />
+                      </DocumentPaneProvider>
+                    </VirtualizerScrollInstanceProvider>
+                  </TypePathContext.Provider>
                 )}
               </Box>
             </PresenceOverlay>
@@ -323,7 +341,6 @@ export function AssistInspector(props: DocumentInspectorProps) {
           </Box>
         </Flex>
       </Card>
-
       <CardWithShadowAbove flex="none" paddingX={4} paddingY={3} style={{justifySelf: 'flex-end'}}>
         <Flex gap={2} flex={1} justify="flex-end">
           {schemaType?.name && pathKey && instructionKey && (
@@ -352,22 +369,28 @@ export function AssistInspector(props: DocumentInspectorProps) {
   )
 }
 
-function AiInspectorHeader(props: {fieldTitle: string; onClose: () => void}) {
-  const {onClose, fieldTitle} = props
+function AiInspectorHeader(props: {fieldTitle: string; field?: FieldRef; onClose: () => void}) {
+  const {onClose, field, fieldTitle} = props
   const {showOnboarding, dismissOnboarding} = useOnboardingFeature(inspectorOnboardingKey)
 
   return (
     <CardWithShadowBelow flex="none" padding={2}>
       <Flex flex={1} align="center">
         <Flex flex={1} padding={3} gap={2} align="center">
-          <Flex gap={1} align="center">
-            <Text size={1} weight="semibold">
-              AI instructions for
-            </Text>
-            <Card radius={2} border padding={1} style={{margin: '-4px 0'}}>
+          <Flex gap={1} align="center" wrap="wrap" style={{marginTop: '-4px'}}>
+            <Box marginTop={1}>
               <Text size={1} weight="semibold">
-                {fieldTitle}
+                AI instructions for
               </Text>
+            </Box>
+            <Card radius={2} border padding={1} marginTop={1}>
+              {field ? (
+                <FieldTitle field={field} />
+              ) : (
+                <Text size={1} weight="semibold">
+                  {fieldTitle}
+                </Text>
+              )}
             </Card>
           </Flex>
         </Flex>

package/src/assistInspector/FieldAutocomplete.tsx

@@ -11,25 +11,29 @@ interface FieldSelectorProps {
   fieldPath?: string
   onSelect: (path: string) => void
   includeDocument?: boolean
+  filter?: (field: FieldRef) => boolean
 }
 
 export function FieldAutocomplete(props: FieldSelectorProps) {
-  const {id, schemaType, fieldPath, onSelect, includeDocument} = props
+  const {id, schemaType, fieldPath, onSelect, includeDocument, filter} = props
 
-  const fieldNames = useMemo(() => {
+  const fieldRefs = useMemo(() => {
     if (includeDocument) {
       return getFieldRefsWithDocument(schemaType)
     }
     return getFieldRefs(schemaType)
   }, [schemaType, includeDocument])
   const currentField = useMemo(
-    () => fieldNames.find((f) => f.key === fieldPath),
-    [fieldPath, fieldNames]
+    () => fieldRefs.find((f) => f.key === fieldPath),
+    [fieldPath, fieldRefs]
   )
 
   const autocompleteOptions = useMemo(
-    () => fieldNames.map((field) => ({value: field.key, field})),
-    [fieldNames]
+    () =>
+      fieldRefs
+        .filter((field) => (filter ? filter(field) : true))
+        .map((field) => ({value: field.key, field})),
+    [fieldRefs, filter]
   )
 
   const renderOption = useCallback((option: {value: string; field: FieldRef}) => {
@@ -55,33 +59,12 @@ export function FieldAutocomplete(props: FieldSelectorProps) {
       )
     }
 
-    const splitTitle = field.title.split('/')
     return (
       <Card as="button" padding={3} radius={1}>
         <Flex gap={3}>
           <Text size={1}>{createElement(field.icon)}</Text>
 
-          <Box flex="none">
-            <Breadcrumbs
-              separator={
-                <Text muted size={1}>
-                  /
-                </Text>
-              }
-              space={1}
-            >
-              {splitTitle.slice(0, splitTitle.length - 1).map((pt, i) => (
-                // eslint-disable-next-line react/no-array-index-key
-                <Text key={i} muted size={1}>
-                  {pt.trim()}
-                </Text>
-              ))}
-
-              <Text size={1} weight="medium">
-                {splitTitle[splitTitle.length - 1]}
-              </Text>
-            </Breadcrumbs>
-          </Box>
+          <FieldTitle field={field} />
         </Flex>
       </Card>
     )
@@ -99,7 +82,6 @@ export function FieldAutocomplete(props: FieldSelectorProps) {
     )
   }, [])
 
-  // const id = useId()
   return (
     <Autocomplete
       fontSize={1}
@@ -117,3 +99,41 @@ export function FieldAutocomplete(props: FieldSelectorProps) {
     />
   )
 }
+
+export function FieldTitle(props: {field: FieldRef}) {
+  const splitTitle = props.field.title.split('/')
+  return (
+    <Box flex="none">
+      <Breadcrumbs
+        style={{
+          display: 'flex',
+          flexWrap: 'wrap',
+          alignItems: 'center',
+          marginTop: '-4px',
+        }}
+        separator={
+          <Box marginTop={1}>
+            <Text muted size={1}>
+              /
+            </Text>
+          </Box>
+        }
+        space={1}
+      >
+        {splitTitle.slice(0, splitTitle.length - 1).map((pt, i) => (
+          // eslint-disable-next-line react/no-array-index-key
+          <Box key={i} marginTop={1}>
+            <Text muted size={1}>
+              {pt.trim()}
+            </Text>
+          </Box>
+        ))}
+        <Box marginTop={1}>
+          <Text size={1} weight="medium">
+            {splitTitle[splitTitle.length - 1]}
+          </Text>
+        </Box>
+      </Breadcrumbs>
+    </Box>
+  )
+}

package/src/assistInspector/helpers.ts

@@ -7,13 +7,24 @@ import {
   OlistIcon,
   StringIcon,
 } from '@sanity/icons'
-import {isObjectSchemaType, ObjectSchemaType, Path, pathToString, SchemaType} from 'sanity'
+import {
+  ArraySchemaType,
+  isKeySegment,
+  isObjectSchemaType,
+  ObjectSchemaType,
+  Path,
+  pathToString,
+  SanityDocumentLike,
+  SchemaType,
+  stringToPath,
+} from 'sanity'
 import {ComponentType, useContext, useMemo} from 'react'
 import {AssistInspectorRouteParams, documentRootKey, fieldPathParam} from '../types'
 import {usePaneRouter} from 'sanity/desk'
 import {isAssistSupported} from '../helpers/assistSupported'
 import {isPortableTextArray, isType} from '../helpers/typeUtils'
 import {SelectedFieldContext} from '../assistDocument/components/SelectedFieldContext'
+import {extractWithPath} from '@sanity/mutator'
 
 export interface FieldRef {
   key: string
@@ -21,9 +32,10 @@ export interface FieldRef {
   title: string
   schemaType: SchemaType
   icon: ComponentType
+  synthetic?: boolean
 }
 
-const maxDepth = 4
+const maxDepth = 6
 
 export function getTypeIcon(schemaType: SchemaType) {
   let t: SchemaType | undefined = schemaType
@@ -73,7 +85,7 @@ export function getFieldRefs(
       const path: Path = parent ? [...parent.path, field.name] : [field.name]
       const title = field.type.title ?? field.name
       const fieldRef: FieldRef = {
-        key: pathToString(path),
+        key: patchableKey(pathToString(path)),
         path,
         title: parent ? [parent.title, title].join(' / ') : title,
         schemaType: field.type,
@@ -82,13 +94,81 @@ export function getFieldRefs(
       const fields =
         field.type.jsonType === 'object' ? getFieldRefs(field.type, fieldRef, depth + 1) : []
 
+      const syntheticFields =
+        field.type.jsonType === 'array' ? getSyntheticFields(field.type, fieldRef, depth + 1) : []
       if (!isAssistSupported(field.type, true)) {
+        return [...fields, ...syntheticFields]
+      }
+      return [fieldRef, ...fields, ...syntheticFields]
+    })
+}
+
+function getSyntheticFields(schemaType: ArraySchemaType, parent?: FieldRef, depth = 0) {
+  if (depth >= maxDepth) {
+    return []
+  }
+
+  return schemaType.of
+    .filter((itemType) => !isType(itemType, 'block'))
+    .flatMap((itemType) => {
+      const segment = {_key: itemType.name}
+      const title = itemType.title ?? itemType.name
+      const path: Path = parent ? [...parent.path, segment] : [segment]
+      const fieldRef: FieldRef = {
+        key: patchableKey(pathToString(path)),
+        path,
+        title: parent ? [parent.title, title].join(' / ') : title,
+        schemaType: itemType,
+        icon: getTypeIcon(itemType),
+        synthetic: true,
+      }
+      const fields =
+        itemType.jsonType === 'object' ? getFieldRefs(itemType, fieldRef, depth + 1) : []
+
+      if (!isAssistSupported(itemType, true)) {
         return fields
       }
       return [fieldRef, ...fields]
     })
 }
 
+export function getTypePath(doc: SanityDocumentLike, pathString: string) {
+  if (!pathString) {
+    return undefined
+  }
+
+  const path = stringToPath(pathString)
+  const currentPath: Path = []
+  let valid = true
+  const syntheticPath = path.map((segment) => {
+    currentPath.push(segment)
+
+    if (isKeySegment(segment)) {
+      const match = extractWithPath(pathToString(currentPath), doc)[0]
+      const value = match?.value
+      if (match && value && typeof value === 'object' && '_type' in value) {
+        return {_key: value._type as string}
+      }
+      valid = false
+    }
+    return segment
+  })
+
+  return valid ? patchableKey(pathToString(syntheticPath)) : undefined
+}
+
+/**
+ * mutator crashes if path contains certain letters
+ * @param pathKey
+ */
+function patchableKey(pathKey: string) {
+  return pathKey.replace(/[=]=/g, ':').replace(/[[\]]/g, '|').replace(/"/g, '')
+}
+
+export function useTypePath(doc: SanityDocumentLike, pathString: string) {
+  return useMemo(() => getTypePath(doc, pathString), [doc, pathString])
+}
+
 export function useSelectedField(
   documentSchemaType?: SchemaType,
   path?: string
@@ -115,7 +195,7 @@ export function useSelectedFieldTitle() {
 
 export function getFieldTitle(field?: FieldRef) {
   const schemaType = field?.schemaType
-  return schemaType?.title ?? schemaType?.name ?? 'Untitled'
+  return field?.title ?? schemaType?.title ?? schemaType?.name ?? 'Untitled'
 }
 
 export function useAiPaneRouter() {

package/src/fieldActions/assistFieldActions.tsx

@@ -11,7 +11,7 @@ import {pluginTitle, pluginTitleShort} from '../constants'
 import {useAssistSupported} from '../helpers/useAssistSupported'
 import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
 import {getInstructionTitle, usePathKey} from '../helpers/misc'
-import {fieldPathParam, instructionParam, StudioInstruction} from '../types'
+import {documentRootKey, fieldPathParam, instructionParam, StudioInstruction} from '../types'
 import {aiInspectorId} from '../assistInspector/constants'
 import {getIcon} from '../assistDocument/components/instruction/appearance/IconInput'
 import {useAssistDocumentContextValue} from '../assistDocument/hooks/useAssistDocumentContextValue'
@@ -21,6 +21,8 @@ import {
 } from '../assistDocument/RequestRunInstructionProvider'
 import {PrivateIcon} from './PrivateIcon'
 import {generateCaptionsActions} from './generateCaptionActions'
+import {useDocumentPane} from 'sanity/desk'
+import {useSelectedField, useTypePath} from '../assistInspector/helpers'
 
 function node(node: DocumentFieldActionItem | DocumentFieldActionGroup) {
   return node
@@ -30,7 +32,6 @@ export const assistFieldActions: DocumentFieldAction = {
   name: 'sanity-assist-actions',
   useAction(props) {
     const {schemaType} = props
-    const assistSupported = useAssistSupported(props.path, schemaType)
 
     const isDocumentLevel = props.path.length === 0
 
@@ -54,9 +55,11 @@ export const assistFieldActions: DocumentFieldAction = {
         : // eslint-disable-next-line react-hooks/rules-of-hooks
           useAssistDocumentContext()
 
+    const {value: docValue} = useDocumentPane()
     const currentUser = useCurrentUser()
     const isHidden = !assistDocument
     const pathKey = usePathKey(props.path)
+    const typePath = useTypePath(docValue, pathKey)
     const assistDocumentId = assistDocument?._id
 
     const assistableDocId = getAssistableDocId(documentSchemaType, documentId)
@@ -65,10 +68,17 @@ export const assistFieldActions: DocumentFieldAction = {
       isDocAssistable: documentIsAssistable ?? false,
     })
 
+    const isSelectable = !!useSelectedField(documentSchemaType, typePath)
+    const assistSupported = useAssistSupported(props.path, schemaType) && isSelectable
+
     const fieldAssist = useMemo(
-      () => (assistDocument?.fields ?? []).find((f) => f.path == pathKey),
-      [assistDocument?.fields, pathKey]
+      () =>
+        (assistDocument?.fields ?? []).find(
+          (f) => f.path === typePath || (pathKey === documentRootKey && f.path === pathKey)
+        ),
+      [assistDocument?.fields, pathKey, typePath]
     )
+
     const fieldAssistKey = fieldAssist?._key
     const isInspectorOpen = inspector?.name === aiInspectorId
     const isPathSelected = pathKey === selectedPath
@@ -96,10 +106,11 @@ export const assistFieldActions: DocumentFieldAction = {
           documentId: assistableDocId,
           assistDocumentId,
           path: pathKey,
+          typePath,
           instruction,
         })
       },
-      [requestRunInstruction, assistableDocId, pathKey, assistDocumentId, fieldAssistKey]
+      [requestRunInstruction, assistableDocId, pathKey, typePath, assistDocumentId, fieldAssistKey]
     )
 
     const privateInstructions = useMemo(

package/src/helpers/useAssistSupported.ts

@@ -3,8 +3,5 @@ import {useMemo} from 'react'
 import {isAssistSupported} from './assistSupported'
 
 export function useAssistSupported(path: Path, schemaType: SchemaType) {
-  return useMemo(
-    () => path.every((p) => typeof p === 'string') && isAssistSupported(schemaType),
-    [path, schemaType]
-  )
+  return useMemo(() => isAssistSupported(schemaType), [schemaType])
 }

package/src/schemas/assistDocumentSchema.tsx

@@ -367,7 +367,7 @@ export const fieldInstructions = defineType({
 
 export const assistDocumentSchema = defineType({
   //NOTE: this is a document type. Using object here ensures it does not appear in structure menus
-  type: 'object',
+  type: 'document',
   //workaround for using object and not document
   ...({liveEdit: true} as any),
   name: assistDocumentTypeName,

package/src/useApiClient.ts

@@ -13,6 +13,7 @@ export interface RunInstructionRequest {
   documentId: string
   assistDocumentId: string
   path: string
+  typePath?: string
   instructionKey: string
   userId?: string
   userTexts?: UserTextInstance[]