@sanity/assist 5.0.4 → 6.0.1

package/src/types.ts

@@ -1,220 +0,0 @@
-import {PortableTextBlock, PortableTextMarkDefinition, PortableTextSpan} from '@portabletext/types'
-import {SanityDocument} from 'sanity'
-
-//id prefixes
-export const assistDocumentIdPrefix = 'sanity.assist.schemaType.'
-export const assistDocumentStatusIdPrefix = 'sanity.assist.status.'
-export const assistSchemaIdPrefix = 'sanity.assist.schema.'
-
-// type names
-export const assistDocumentTypeName = 'sanity.assist.schemaType.annotations' as const
-export const assistFieldTypeName = 'sanity.assist.schemaType.field' as const
-export const instructionTypeName = 'sanity.assist.instruction' as const
-export const promptTypeName = 'sanity.assist.instruction.prompt' as const
-
-export const userInputTypeName = 'sanity.assist.instruction.userInput' as const
-export const instructionContextTypeName = 'sanity.assist.instruction.context' as const
-export const fieldReferenceTypeName = 'sanity.assist.instruction.fieldRef' as const
-
-// user-facing type. Intentionally does not have sanity. prefix
-export const contextDocumentTypeName = 'assist.instruction.context' as const
-
-export const assistTasksStatusTypeName = 'sanity.assist.task.status' as const
-export const instructionTaskTypeName = 'sanity.assist.instructionTask' as const
-export const fieldPresenceTypeName = 'sanity.assist.instructionTask.presence' as const
-
-export const assistSerializedTypeName = 'sanity.assist.serialized.type' as const
-export const assistSerializedFieldTypeName = 'sanity.assist.serialized.field' as const
-
-export const outputFieldTypeName = 'sanity.assist.output.field' as const
-export const outputTypeTypeName = 'sanity.assist.output.type' as const
-
-//url params
-export const inspectParam = 'inspect' as const
-export const fieldPathParam = 'pathKey' as const
-export const instructionParam = 'instruction' as const
-
-// other constants
-export const documentRootKey = '<document>'
-
-export type SerializedSchemaMember = Omit<SerializedSchemaType, 'name' | '_type'> & {
-  _type?: typeof assistSerializedFieldTypeName
-  name?: string
-}
-
-export interface SerializedSchemaType {
-  _type?: typeof assistSerializedTypeName
-  _id?: string
-  type: string
-  name: string
-  title?: string
-  fields?: SerializedSchemaMember[]
-  of?: SerializedSchemaMember[]
-  to?: SerializedSchemaMember[]
-  annotations?: SerializedSchemaMember[]
-  inlineOf?: SerializedSchemaMember[]
-  values?: string[] | {value: string; title?: string}[]
-  hidden?: boolean | 'function'
-  readOnly?: boolean | 'function'
-  options?: {
-    /** equivalent to options.aiAssist.imageDescriptionField - not renamed in the api for backwards compatability */
-    imagePromptField?: string
-    embeddingsIndex?: string
-  }
-}
-
-export interface AssistDocument extends SanityDocument {
-  fields?: AssistField[]
-  instructions?: StudioInstruction[]
-}
-
-export interface PresetInstruction {
-  _key: string
-  prompt?: PromptTextBlock[]
-
-  title?: string
-  /**
-   * String key from `@sanity/icons` IconMap
-   */
-  icon?: string
-
-  /**
-   * Type/field filter
-   */
-  output?: (OutputFieldItem | OutputTypeItem)[]
-}
-
-export interface PresetField {
-  path?: string
-  instructions?: PresetInstruction[]
-}
-
-export interface AssistPreset {
-  fields?: PresetField[]
-}
-
-export interface SanityAssistDocument {
-  _id: string
-  _type: typeof assistDocumentTypeName
-  fields?: StudioAssistField[]
-}
-
-export interface StudioAssistDocument extends SanityAssistDocument {
-  // added after loading
-  tasks?: InstructionTask[]
-}
-
-export interface AssistField {
-  _key: string
-  _type: typeof assistFieldTypeName
-  path?: string
-  instructions?: StudioInstruction[]
-}
-
-export interface StudioAssistField {
-  _key: string
-  path?: string
-  instructions?: StudioInstruction[]
-
-  // added
-  tasks?: InstructionTask[]
-}
-
-export interface FieldRef extends PortableTextMarkDefinition {
-  _type: typeof fieldReferenceTypeName
-  path?: string
-}
-
-export interface ContextBlock {
-  _type: typeof instructionContextTypeName
-  reference?: {
-    _type: 'reference'
-    _ref?: string
-  }
-}
-
-export interface UserInputBlock {
-  _type: typeof userInputTypeName
-  _key: string
-  message?: string
-  description?: string
-}
-
-export type InlinePromptBlock = PortableTextSpan | FieldRef | UserInputBlock | ContextBlock
-export type PromptTextBlock = Omit<
-  PortableTextBlock<never, InlinePromptBlock, 'normal', never>,
-  '_type'
-> & {_type: 'block'}
-
-export type PromptBlock = PromptTextBlock | FieldRef | ContextBlock | UserInputBlock
-
-export interface AiPresence {
-  _key: string
-  _type: typeof fieldPresenceTypeName
-  path?: string
-  started?: string
-}
-
-export type TaskEndedReason = 'success' | 'error' | 'aborted' | 'timeout'
-
-export interface InstructionTask {
-  _key: string
-  _type: typeof instructionTaskTypeName
-  instructionKey?: string
-  title?: string
-  path?: string
-  started?: string
-  updated?: string
-  ended?: string
-  message?: string
-  reason?: TaskEndedReason
-  presence?: AiPresence[]
-  startedByUserId?: string
-
-  //added by studio
-  // eslint-disable-next-line no-use-before-define
-  instruction?: StudioInstruction
-}
-
-export interface StudioInstruction {
-  _key: string
-  _type: typeof instructionTypeName
-  prompt?: PromptBlock[]
-
-  icon?: string
-  userId?: string
-  title?: string
-  placeholder?: string
-  output?: (OutputFieldItem | OutputTypeItem)[]
-
-  //added after query / synthetic fields
-  tasks?: InstructionTask[]
-}
-
-export interface AssistTasksStatus {
-  _id: string
-  _type: typeof assistTasksStatusTypeName
-  tasks?: InstructionTask[]
-}
-
-export interface AssistInspectorRouteParams {
-  [inspectParam]?: string
-  [fieldPathParam]?: string
-  [instructionParam]?: string
-}
-
-export interface OutputFieldItem {
-  _type: typeof outputFieldTypeName
-  _key: string
-  //path relative to the field the instruction is for (same as _key)
-  relativePath?: string
-}
-
-export interface OutputTypeItem {
-  _type: typeof outputTypeTypeName
-  _key: string
-  /* array item type name */
-  type?: string
-  //path relative to the array-field the instruction is for, can be empty string (the array itself, same as _key)
-  relativePath?: string
-}

package/src/useApiClient.ts

@@ -1,338 +0,0 @@
-import type {SanityClient} from '@sanity/client'
-import {useToast} from '@sanity/ui'
-import {useCallback, useMemo, useState} from 'react'
-import {Path, pathToString, useClient, useCurrentUser} from 'sanity'
-
-import {useAiAssistanceConfig, useSerializedTypes} from './assistLayout/AiAssistanceConfigContext'
-import {ConditionalMemberState} from './helpers/conditionalMembers'
-import {FieldLanguageMap} from './translate/paths'
-import {documentRootKey} from './types'
-
-export interface UserTextInstance {
-  blockKey: string
-  userInput: string
-}
-
-export interface RunInstructionRequest {
-  documentId: string
-  assistDocumentId: string
-  path: string
-  typePath?: string
-  instructionKey: string
-  userId?: string
-  userTexts?: UserTextInstance[]
-  conditionalMembers?: ConditionalMemberState[]
-}
-
-export interface InstructStatus {
-  enabled: boolean
-  initialized: boolean
-  validToken: boolean
-}
-
-export interface TranslateRequest {
-  documentId: string
-  translatePath: Path
-  languagePath?: string
-  styleguide: () => Promise<string | undefined>
-  fieldLanguageMap?: FieldLanguageMap[]
-  conditionalMembers?: ConditionalMemberState[]
-}
-
-const basePath = '/assist/tasks/instruction'
-export const API_VERSION_WITH_EXTENDED_TYPES = '2025-04-01'
-
-export function canUseAssist(status: InstructStatus | undefined) {
-  return status?.enabled && status.initialized && status.validToken
-}
-
-export function useApiClient(customApiClient?: (defaultClient: SanityClient) => SanityClient) {
-  const client = useClient({apiVersion: API_VERSION_WITH_EXTENDED_TYPES})
-  return useMemo(
-    () => (customApiClient ? customApiClient(client) : client),
-    [client, customApiClient],
-  )
-}
-
-export function useTranslate(apiClient: SanityClient) {
-  const [loading, setLoading] = useState(false)
-  const user = useCurrentUser()
-  const types = useSerializedTypes()
-  const toast = useToast()
-
-  const translate = useCallback(
-    ({
-      documentId,
-      languagePath,
-      styleguide,
-      translatePath,
-      fieldLanguageMap,
-      conditionalMembers,
-    }: TranslateRequest) => {
-      setLoading(true)
-
-      async function run() {
-        return apiClient.request({
-          method: 'POST',
-          url: `/assist/tasks/translate/${apiClient.config().dataset}?projectId=${
-            apiClient.config().projectId
-          }`,
-          body: {
-            documentId,
-            types,
-            languagePath,
-            userStyleguide: await styleguide(),
-            fieldLanguageMap,
-            conditionalMembers,
-            translatePath:
-              translatePath.length === 0 ? documentRootKey : pathToString(translatePath),
-            userId: user?.id,
-          },
-        })
-      }
-
-      return run()
-        .catch((e) => {
-          toast.push({
-            status: 'error',
-            title: 'Translate failed',
-            description: e.message,
-          })
-          setLoading(false)
-          throw e
-        })
-        .finally(() => {
-          // adding some artificial delay here
-          // server responds with 201 then proceeds; we dont need to allow spamming the button
-          setTimeout(() => {
-            setLoading(false)
-          }, 2000)
-        })
-    },
-    [setLoading, apiClient, toast, user, types],
-  )
-
-  return useMemo(
-    () => ({
-      translate,
-      loading,
-    }),
-    [translate, loading],
-  )
-}
-
-export function useGenerateCaption(apiClient: SanityClient) {
-  const [loading, setLoading] = useState(false)
-  const user = useCurrentUser()
-  const types = useSerializedTypes()
-  const toast = useToast()
-
-  const generateCaption = useCallback(
-    ({path, documentId}: {path: string; documentId: string}) => {
-      setLoading(true)
-
-      return apiClient
-        .request({
-          method: 'POST',
-          url: `/assist/tasks/generate-caption/${apiClient.config().dataset}?projectId=${
-            apiClient.config().projectId
-          }`,
-          body: {
-            path,
-            documentId,
-            types,
-            userId: user?.id,
-          },
-        })
-        .catch((e) => {
-          toast.push({
-            status: 'error',
-            title: 'Generate image description failed',
-            description: e.message,
-          })
-          setLoading(false)
-          throw e
-        })
-        .finally(() => {
-          // adding some artificial delay here
-          // server responds with 201 then proceeds; we dont need to allow spamming the button
-          setTimeout(() => {
-            setLoading(false)
-          }, 2000)
-        })
-    },
-    [setLoading, apiClient, toast, user, types],
-  )
-
-  return useMemo(
-    () => ({
-      generateCaption,
-      loading,
-    }),
-    [generateCaption, loading],
-  )
-}
-
-export function useGenerateImage(apiClient: SanityClient) {
-  const [loading, setLoading] = useState(false)
-  const user = useCurrentUser()
-  const types = useSerializedTypes()
-  const toast = useToast()
-
-  const generateImage = useCallback(
-    ({path, documentId}: {path: string; documentId: string}) => {
-      setLoading(true)
-
-      return apiClient
-        .request({
-          method: 'POST',
-          url: `/assist/tasks/generate-image/${apiClient.config().dataset}?projectId=${
-            apiClient.config().projectId
-          }`,
-          body: {
-            path,
-            documentId,
-            types,
-            userId: user?.id,
-          },
-        })
-        .catch((e) => {
-          toast.push({
-            status: 'error',
-            title: 'Generate image from prompt failed',
-            description: e.message,
-          })
-          setLoading(false)
-          throw e
-        })
-        .finally(() => {
-          // adding some artificial delay here
-          // server responds with 201 then proceeds; we dont need to allow spamming the button
-          setTimeout(() => {
-            setLoading(false)
-          }, 2000)
-        })
-    },
-    [setLoading, apiClient, toast, user, types],
-  )
-
-  return useMemo(
-    () => ({
-      generateImage,
-      loading,
-    }),
-    [generateImage, loading],
-  )
-}
-
-export function useGetInstructStatus(apiClient: SanityClient) {
-  const [loading, setLoading] = useState(true)
-
-  const getInstructStatus = useCallback(async () => {
-    setLoading(true)
-
-    const projectId = apiClient.config().projectId
-    try {
-      const status = await apiClient.request<InstructStatus>({
-        method: 'GET',
-        url: `${basePath}/${apiClient.config().dataset}/status?projectId=${projectId}`,
-      })
-
-      return status
-    } finally {
-      setLoading(false)
-    }
-  }, [setLoading, apiClient])
-
-  return {
-    loading,
-    getInstructStatus,
-  }
-}
-
-export function useInitInstruct(apiClient: SanityClient) {
-  const [loading, setLoading] = useState(false)
-  const initInstruct = useCallback(() => {
-    setLoading(true)
-    return apiClient
-      .request({
-        method: 'GET',
-        url: `${basePath}/${apiClient.config().dataset}/init?projectId=${
-          apiClient.config().projectId
-        }`,
-      })
-      .finally(() => {
-        setLoading(false)
-      })
-  }, [setLoading, apiClient])
-
-  return {
-    loading,
-    initInstruct,
-  }
-}
-
-export function useRunInstructionApi(apiClient: SanityClient) {
-  const toast = useToast()
-  const [loading, setLoading] = useState(false)
-  const user = useCurrentUser()
-  const types = useSerializedTypes()
-
-  const {
-    config: {assist: assistConfig},
-  } = useAiAssistanceConfig()
-
-  const runInstruction = useCallback(
-    (request: RunInstructionRequest) => {
-      if (!user) {
-        toast.push({
-          status: 'error',
-          title: 'Unable to get user for instruction.',
-        })
-        return undefined
-      }
-      setLoading(true)
-
-      const {timeZone, locale} = Intl.DateTimeFormat().resolvedOptions()
-      const defaultLocaleSettings = {timeZone, locale}
-      const localeSettings =
-        assistConfig?.localeSettings?.({user, defaultSettings: defaultLocaleSettings}) ??
-        defaultLocaleSettings
-
-      return apiClient
-        .request({
-          method: 'POST',
-          url: `${basePath}/${apiClient.config().dataset}?projectId=${
-            apiClient.config().projectId
-          }`,
-          body: {
-            ...request,
-            types,
-            userId: user?.id,
-            localeSettings,
-            maxPathDepth: assistConfig?.maxPathDepth,
-          },
-        })
-        .catch((e) => {
-          toast.push({
-            status: 'error',
-            title: 'Instruction failed',
-            description: e.message,
-          })
-          throw e
-        })
-        .finally(() => {
-          setLoading(false)
-        })
-    },
-    [apiClient, types, user, toast, assistConfig],
-  )
-
-  return useMemo(
-    () => ({
-      runInstruction,
-      loading,
-    }),
-    [runInstruction, loading],
-  )
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version, sanityExchangeUrl} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: undefined,
-  },
-  sanityExchangeUrl,
-})