@sanity/assist 3.1.1 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/assist",
-  "version": "3.1.1",
+  "version": "3.2.1",
   "description": "You create the instructions; Sanity AI Assist does the rest.",
   "keywords": [
     "sanity",
@@ -65,6 +65,7 @@
     "@rollup/plugin-image": "^3.0.3",
     "@sanity/pkg-utils": "^6.1.0",
     "@sanity/plugin-kit": "^3.1.10",
+    "@sanity/schema": "^3.80.0",
     "@sanity/semantic-release-preset": "^4.1.7",
     "@types/lodash": "^4.17.0",
     "@types/lodash-es": "^4.17.12",
@@ -75,13 +76,14 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-sanity": "^7.1.2",
     "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-react": "^7.34.1",
     "eslint-plugin-react-hooks": "^4.6.0",
     "npm-run-all2": "^5.0.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rimraf": "^5.0.5",
-    "sanity": "^3.74.1",
+    "sanity": "^3.80.0",
     "semantic-release": "^23.0.8",
     "styled-components": "^6.1.8",
     "typescript": "^5.7.2",

package/src/_lib/fixedListenQuery.ts

@@ -1,4 +1,4 @@
-import {SanityClient} from '@sanity/client'
+import type {SanityClient} from '@sanity/client'
 import {defer, delay, merge, Observable, of, partition, switchMap, throwError} from 'rxjs'
 import {filter, mergeMap, share, take} from 'rxjs/operators'
 import {exhaustMapToWithTrailing} from 'rxjs-exhaustmap-with-trailing'

package/src/assistInspector/AssistInspector.tsx

@@ -15,6 +15,7 @@ import {
 import {styled} from 'styled-components'
 
 import {DocumentForm} from '../_lib/form'
+import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
 import {AssistTypeContext} from '../assistDocument/components/AssistTypeContext'
 import {useStudioAssistDocument} from '../assistDocument/hooks/useStudioAssistDocument'
 import {useRequestRunInstruction} from '../assistDocument/RequestRunInstructionProvider'
@@ -34,7 +35,6 @@ import {
   useTypePath,
 } from './helpers'
 import {InstructionTaskHistoryButton} from './InstructionTaskHistoryButton'
-import {useAssistDocumentContext} from '../assistDocument/AssistDocumentContext'
 
 const CardWithShadowBelow = styled(Card)`
   position: relative;

package/src/helpers/assistSupported.ts

@@ -37,6 +37,7 @@ function isUnsupportedType(type: SchemaType) {
     type.jsonType === 'number' ||
     type.name === 'sanity.imageCrop' ||
     type.name === 'sanity.imageHotspot' ||
+    isType(type, 'globalDocumentReference') ||
     (isType(type, 'reference') &&
       !(type?.options as ReferenceOptions)?.aiAssist?.embeddingsIndex) ||
     isType(type, 'crossDatasetReference') ||

package/src/helpers/conditionalMembers.test.ts

@@ -226,4 +226,51 @@ describe('conditionalMembers', () => {
       },
     ])
   })
+
+  test('should respect max-depth', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title', readOnly: () => false},
+            {
+              type: 'object',
+              name: 'object',
+              fields: [{type: 'string', name: 'title', readOnly: () => false}],
+            },
+          ],
+        }),
+      ],
+    }).get('article')
+
+    const docState = {
+      path: [],
+      schemaType: docSchema,
+      members: [
+        {
+          kind: 'field',
+          field: {path: [docSchema.fields[0].name], schemaType: docSchema.fields[0].type},
+        },
+        {
+          kind: 'field',
+          field: {
+            path: [docSchema.fields[1].name],
+            schemaType: docSchema.fields[1].type,
+            members: [
+              {
+                kind: 'field',
+                field: {path: ['object', 'title'], schemaType: docSchema.fields[0].type},
+              },
+            ],
+          },
+        },
+      ],
+    } as any
+    const conditionalMembers = getConditionalMembers(docState, 1)
+
+    expect(conditionalMembers).toEqual([{path: 'title', hidden: false, readOnly: false}])
+  })
 })

package/src/helpers/conditionalMembers.ts

@@ -12,7 +12,8 @@ import {
   type SchemaType,
 } from 'sanity'
 
-const MAX_DEPTH = 8
+const DEFAULT_MAX_DEPTH = 8
+const ABSOLUTE_MAX_DEPTH = 50
 
 export interface ConditionalMemberState {
   path: string
@@ -37,7 +38,10 @@ interface ConditionalMemberInnerState extends ConditionalMemberState {
  * * If a parent path is readOnly, no child paths are included
  * * If a path is hidden, it is not included; only conditionally visible paths will be returned, with hidden: false
  */
-export function getConditionalMembers(docState: DocumentFormNode): ConditionalMemberState[] {
+export function getConditionalMembers(
+  docState: DocumentFormNode,
+  maxDepth = DEFAULT_MAX_DEPTH,
+): ConditionalMemberState[] {
   const doc: ConditionalMemberInnerState = {
     path: '',
     hidden: false,
@@ -45,7 +49,7 @@ export function getConditionalMembers(docState: DocumentFormNode): ConditionalMe
     conditional: isConditional(docState.schemaType),
   }
   return (
-    [doc, ...extractConditionalPaths(docState, MAX_DEPTH)]
+    [doc, ...extractConditionalPaths(docState, Math.min(maxDepth, ABSOLUTE_MAX_DEPTH))]
       .filter((v) => v.conditional)
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       .map(({conditional, ...state}) => ({...state}))

package/src/index.ts

@@ -1,9 +1,6 @@
-export * from './schemas/typeDefExtensions'
+export {assist} from './plugin'
 export * from './schemas/serialize/SchemTypeTool'
-
+export * from './schemas/typeDefExtensions'
 export {defaultLanguageOutputs} from './translate/paths'
 export * from './translate/types'
-
 export {contextDocumentTypeName} from './types'
-
-export {assist} from './plugin'

package/src/plugin.tsx

@@ -1,23 +1,24 @@
+import type {SanityClient} from '@sanity/client'
 import {definePlugin, isObjectSchemaType} from 'sanity'
-import {assistInspector} from './assistInspector'
+
+import {AssistDocumentInputWrapper} from './assistDocument/AssistDocumentInput'
+import {AssistDocumentLayout} from './assistDocument/AssistDocumentLayout'
 import {AssistFieldWrapper} from './assistFormComponents/AssistField'
-import {AssistLayout} from './assistLayout/AssistLayout'
 import {AssistFormBlock} from './assistFormComponents/AssistFormBlock'
+import {AssistInlineFormBlock} from './assistFormComponents/AssistInlineFormBlock'
 import {AssistItem} from './assistFormComponents/AssistItem'
-import {SanityClient} from '@sanity/client'
+import {assistInspector} from './assistInspector'
+import {AssistLayout} from './assistLayout/AssistLayout'
+import {ImageContextProvider} from './components/ImageContext'
 import {SafeValueInput} from './components/SafeValueInput'
-import {schemaTypes} from './schemas'
-import {AssistInlineFormBlock} from './assistFormComponents/AssistInlineFormBlock'
-import {assistFieldActions} from './fieldActions/assistFieldActions'
 import {packageName} from './constants'
-import {AssistDocumentInputWrapper} from './assistDocument/AssistDocumentInput'
-import {createAssistDocumentPresence} from './presence/AssistDocumentPresence'
+import {assistFieldActions} from './fieldActions/assistFieldActions'
 import {isSchemaAssistEnabled} from './helpers/assistSupported'
 import {isImage} from './helpers/typeUtils'
-import {ImageContextProvider} from './components/ImageContext'
+import {createAssistDocumentPresence} from './presence/AssistDocumentPresence'
+import {schemaTypes} from './schemas'
 import {TranslationConfig} from './translate/types'
 import {assistDocumentTypeName, AssistPreset} from './types'
-import {AssistDocumentLayout} from './assistDocument/AssistDocumentLayout'
 
 export interface AssistPluginConfig {
   translate?: TranslationConfig
@@ -35,6 +36,14 @@ export interface AssistPluginConfig {
 
 export const assist = definePlugin<AssistPluginConfig | void>((config) => {
   const configWithDefaults = config ?? {}
+  const styleguide = configWithDefaults.translate?.styleguide || ''
+
+  if (styleguide.length > 2000) {
+    throw new Error(
+      `[${packageName}]: \`translate.styleguide\` value is too long. It must be 2000 characters or less, was ${styleguide.length} characters`,
+    )
+  }
+
   return {
     name: packageName,
 

package/src/schemas/serialize/schemaUtils.ts

@@ -11,6 +11,7 @@ export const hiddenTypes = [
   'document',
   'email',
   'file',
+  'globalDocumentReference',
   'image',
   'number',
   'object',

package/src/schemas/serialize/serializeSchema.test.ts

@@ -741,4 +741,63 @@ describe('serializeSchema', () => {
       },
     ])
   })
+
+  test('should no serialize global document reference types (for now)', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'object',
+          name: 'author',
+          fields: [
+            defineField({
+              type: 'string',
+              name: 'name',
+            }),
+            defineField({
+              type: 'globalDocumentReference',
+              name: 'person',
+              title: 'Person',
+              resourceType: 'dataset',
+              resourceId: 'exx11uqh.blog',
+              to: [
+                {
+                  type: 'person',
+                  preview: {
+                    select: {
+                      title: 'title',
+                      media: 'coverImage',
+                    },
+                    prepare(val: any) {
+                      return {
+                        title: val.title,
+                        media: val.coverImage,
+                      }
+                    },
+                  },
+                },
+              ],
+            }),
+          ],
+        }),
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        fields: [
+          {
+            name: 'name',
+            title: 'Name',
+            type: 'string',
+          },
+        ],
+        name: 'author',
+        title: 'Author',
+        type: 'object',
+      },
+    ])
+  })
 })

package/src/schemas/serialize/serializeSchema.ts

@@ -58,6 +58,7 @@ function getSchemaStub(
   options?: Options,
 ): SerializedSchemaType {
   if (!schemaType.type?.name) {
+    // eslint-disable-next-line no-console -- log error
     console.error('Missing type name', schemaType.type)
     throw new Error('Type is missing name!')
   }

package/src/translate/FieldTranslationProvider.tsx

@@ -68,6 +68,7 @@ function hasValuesToTranslate(
 export function FieldTranslationProvider(props: PropsWithChildren<{}>) {
   const {config: assistConfig} = useAiAssistanceConfig()
   const apiClient = useApiClient(assistConfig.__customApiClient)
+  const styleguide = assistConfig.translate?.styleguide
   const config = assistConfig.translate?.field
   const {translate: runTranslate} = useTranslate(apiClient)
 
@@ -112,7 +113,7 @@ export function FieldTranslationProvider(props: PropsWithChildren<{}>) {
       setToLanguages(filteredToLanguages)
       const fromId = from?.id
       const allToIds = allToLanguages?.map((l) => l.id) ?? []
-      const docMembers = getDocumentMembersFlat(document, documentSchema)
+      const docMembers = getDocumentMembersFlat(document, documentSchema, config?.maxPathDepth)
       if (fromId && allToIds?.length) {
         const transMap = getFieldLanguageMap(
           documentSchema,
@@ -193,7 +194,8 @@ export function FieldTranslationProvider(props: PropsWithChildren<{}>) {
     if (fieldLanguageMaps && documentId && translatePath) {
       runTranslate({
         documentId,
-        translatePath: translatePath,
+        translatePath,
+        styleguide,
         fieldLanguageMap: fieldLanguageMaps.map((map) => ({
           ...map,
           // eslint-disable-next-line max-nested-callbacks
@@ -207,6 +209,7 @@ export function FieldTranslationProvider(props: PropsWithChildren<{}>) {
     fieldLanguageMaps,
     documentId,
     runTranslate,
+    styleguide,
     close,
     toLanguages,
     fieldTranslationParams?.translatePath,

package/src/translate/paths.test.ts

@@ -137,4 +137,45 @@ describe('paths', () => {
       'translations[_key=="en"].value',
     ])
   })
+
+  test('should limit depth to 1 when specified', () => {
+    const docSchema: ObjectSchemaType = Schema.compile({
+      name: 'test',
+      types: [
+        defineType({
+          type: 'document',
+          name: 'article',
+          fields: [
+            {
+              type: 'array',
+              name: 'translations',
+              of: [
+                {
+                  type: 'object',
+                  name: 'internationalizedArrayString',
+                  fields: [{type: 'string', name: 'value'}],
+                },
+              ],
+            },
+          ],
+        }),
+      ],
+    }).get('article')
+
+    const doc: SanityDocumentLike = {
+      _id: 'na',
+      _type: 'article',
+      translations: [
+        {
+          //assume type is missing in the data for some reason
+          //_type: 'internationalizedArrayString',
+          _key: 'en',
+          value: 'some string',
+        },
+      ],
+    }
+
+    const members = getDocumentMembersFlat(doc, docSchema, 1)
+    expect(members.map((p) => pathToString(p.path))).toEqual(['translations'])
+  })
 })

package/src/translate/paths.ts

@@ -16,15 +16,20 @@ export interface FieldLanguageMap {
   outputs: TranslationOutput[]
 }
 
-const MAX_DEPTH = 6
+const DEFAULT_MAX_DEPTH = 6
+const ABSOLUTE_MAX_DEPTH = 50
 
-export function getDocumentMembersFlat(doc: SanityDocumentLike, schemaType: ObjectSchemaType) {
+export function getDocumentMembersFlat(
+  doc: SanityDocumentLike,
+  schemaType: ObjectSchemaType,
+  maxDepth = DEFAULT_MAX_DEPTH,
+) {
   if (!isDocumentSchemaType(schemaType)) {
     console.error(`Schema type is not a document`)
     return []
   }
 
-  return extractPaths(doc, schemaType, [], MAX_DEPTH)
+  return extractPaths(doc, schemaType, [], Math.min(maxDepth, ABSOLUTE_MAX_DEPTH))
 }
 
 function extractPaths(
@@ -59,7 +64,9 @@ function extractPaths(
     } else if (
       fieldSchema.jsonType === 'array' &&
       fieldSchema.of.length &&
-      fieldSchema.of.some((item) => 'fields' in item)
+      fieldSchema.of.some((item) => 'fields' in item) &&
+      // no reason to drill into arrays if the item fields will be culled by maxDepth, ie we need 1 extra path headroom
+      path.length + 1 < maxDepth
     ) {
       const {value: arrayValue} = extractWithPath(pathToString(fieldPath), doc)[0] ?? {}
 

package/src/translate/translateActions.tsx

@@ -73,6 +73,7 @@ export const translateActions: DocumentFieldAction = {
         task: translationApi.translate,
       })
 
+      const styleguide = config.translate?.styleguide
       const languagePath = config.translate?.document?.languageField
 
       // if this is true, it is stable, and not breaking rules of hooks
@@ -98,6 +99,7 @@ export const translateActions: DocumentFieldAction = {
             translate({
               languagePath,
               translatePath: path,
+              styleguide,
               documentId: documentId ?? '',
               conditionalMembers: formStateRef.current
                 ? getConditionalMembers(formStateRef.current)
@@ -110,6 +112,7 @@ export const translateActions: DocumentFieldAction = {
       }, [
         languagePath,
         translate,
+        styleguide,
         documentId,
         translationApi.loading,
         documentTranslationEnabled,
@@ -123,6 +126,7 @@ export const translateActions: DocumentFieldAction = {
         task: fieldTranslate.openFieldTranslation,
       })
 
+      const maxDepth = config.translate?.field?.maxPathDepth
       const translateFieldsAction = useMemo(
         () =>
           fieldTransEnabled
@@ -148,7 +152,7 @@ export const translateActions: DocumentFieldAction = {
                     documentSchema: documentSchemaType,
                     translatePath: path,
                     conditionalMembers: formStateRef.current
-                      ? getConditionalMembers(formStateRef.current)
+                      ? getConditionalMembers(formStateRef.current, maxDepth)
                       : [],
                   })
                 },
@@ -164,6 +168,7 @@ export const translateActions: DocumentFieldAction = {
           fieldTransEnabled,
           path,
           readOnly,
+          maxDepth,
         ],
       )
 

package/src/translate/types.ts

@@ -76,7 +76,6 @@ export interface FieldTranslationConfig {
    *
    *  It determines the relationships between document paths: Given a document path and a language, into which
    *  sibling paths should translations be output.
-
    *
    * `translationOutputs` is invoked once per path in the document (limited to a depth of 6), with the following:
    *
@@ -121,8 +120,24 @@ export interface FieldTranslationConfig {
    *   return undefined
    * }
    * ```
+   *
+   * @see #maxPathDepth
    **/
   translationOutputs?: TranslationOutputsFunction
+
+  /**
+   * The max depth for document paths AI Assist will translate.
+   *
+   * Depth is based on field path segments:
+   * - `title` has depth 1
+   * - `array[_key="no"].title` has depth 3
+   *
+   * Be careful not to set this too high in studios with recursive document schemas, as it could have
+   * negative impact on performance.
+   *
+   * Default: 6
+   */
+  maxPathDepth?: number
 }
 
 export interface DocumentTranslationConfig {
@@ -157,4 +172,10 @@ export interface TranslationConfig {
    * Config for document types with a single language field that determines the language for the whole document.
    */
   document?: DocumentTranslationConfig
+  /**
+   * A "style guide" that can be used to provide guidance on how to translate content.
+   * Will be passed to the LLM - ergo this is only a guide and the model _may_ not
+   * always follow it to the letter.
+   */
+  styleguide?: string
 }

package/src/types.ts

@@ -1,5 +1,5 @@
-import {SanityDocument} from 'sanity'
 import {PortableTextBlock, PortableTextMarkDefinition, PortableTextSpan} from '@portabletext/types'
+import {SanityDocument} from 'sanity'
 
 //id prefixes
 export const assistDocumentIdPrefix = 'sanity.assist.schemaType.'

package/src/useApiClient.ts

@@ -1,11 +1,12 @@
-import {Path, pathToString, useClient, useCurrentUser, useSchema} from 'sanity'
+import type {SanityClient} from '@sanity/client'
+import {useToast} from '@sanity/ui'
 import {useCallback, useMemo, useState} from 'react'
+import {Path, pathToString, useClient, useCurrentUser, useSchema} from 'sanity'
+
+import {ConditionalMemberState} from './helpers/conditionalMembers'
 import {serializeSchema} from './schemas/serialize/serializeSchema'
-import {useToast} from '@sanity/ui'
-import {SanityClient} from '@sanity/client'
 import {FieldLanguageMap} from './translate/paths'
 import {documentRootKey} from './types'
-import {ConditionalMemberState} from './helpers/conditionalMembers'
 
 export interface UserTextInstance {
   blockKey: string
@@ -33,6 +34,7 @@ export interface TranslateRequest {
   documentId: string
   translatePath: Path
   languagePath?: string
+  styleguide?: string
   fieldLanguageMap?: FieldLanguageMap[]
   conditionalMembers?: ConditionalMemberState[]
 }
@@ -62,6 +64,7 @@ export function useTranslate(apiClient: SanityClient) {
     ({
       documentId,
       languagePath,
+      styleguide,
       translatePath,
       fieldLanguageMap,
       conditionalMembers,
@@ -78,6 +81,7 @@ export function useTranslate(apiClient: SanityClient) {
             documentId,
             types,
             languagePath,
+            userStyleguide: styleguide,
             fieldLanguageMap,
             conditionalMembers,
             translatePath: