Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

49.2 KB
Raw Blame
import type {
  GetWorkspacesCurrentPluginByCategoryListData,
  ParserMarketplaceUpgrade,
  PluginCategoryInstalledPluginResponse,
  PluginCategoryListResponse,
  PluginEntity,
  PluginInstallationItemResponse,
  PluginInstallTask,
  PluginInstallTaskStartResponse,
  PluginListResponse,
  PluginParameterOption,
} from '@dify/contracts/api/console/workspaces/types.gen'
import type {
  PluginInfoFromMarketPlace,
  PluginsFromMarketplaceByInfoResponse,
  PluginsFromMarketplaceResponse,
} from '@dify/contracts/marketplace'
import type { InfiniteData, MutateOptions, QueryClient, QueryOptions } from '@tanstack/react-query'
import type { FormOption } from '@/app/components/header/account-setting/model-provider-page/declarations'
import type { AutoUpdateConfig } from '@/app/components/plugins/reference-setting-modal/auto-update-setting/types'
import type {
  Dependency,
  GitHubItemAndMarketPlaceDependency,
  InstallStatusResponse,
  MetaData,
  PackageDependency,
  Permissions,
  Plugin,
  PluginDeclaration,
  PluginDetail,
  PluginTask,
  ReferenceSetting,
  VersionInfo,
} from '@/app/components/plugins/types'
import type { Collection } from '@/app/components/tools/types'
import {
  zAgentStrategyProviderEntity,
  zDatasourceProviderEntity,
  zEndpointProviderDeclarationResponse,
} from '@dify/contracts/api/console/workspaces/zod.gen'
import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { cloneDeep } from 'es-toolkit/object'
import { useAtomValue } from 'jotai'
import { useCallback, useEffect, useRef } from 'react'
import { FormTypeEnum } from '@/app/components/base/form/types'
import useRefreshPluginList from '@/app/components/plugins/install-plugin/hooks/use-refresh-plugin-list'
import { getFormattedPlugin } from '@/app/components/plugins/marketplace/utils'
import { PluginCategoryEnum, PluginSource, TaskStatus } from '@/app/components/plugins/types'
import { workspacePermissionKeysAtom } from '@/context/permission-state'
import { consoleClient, consoleQuery } from '@/service/console'
import { uninstallPlugin } from '@/service/plugins'
import { hasPermission } from '@/utils/permission'
// oxlint-disable-next-line no-restricted-imports
import { getMarketplace, postMarketplace } from './base'

const NAME_SPACE = 'plugins'
const usePluginTaskListKey = [NAME_SPACE, 'pluginTaskList']

type PluginTaskListResponse = {
  tasks: PluginTask[]
}

const getString = (value: unknown) => {
  return typeof value === 'string' ? value : ''
}

const getBoolean = (value: unknown) => {
  return value === true
}

const getNumber = (value: unknown) => {
  return typeof value === 'number' ? value : undefined
}

const isRecord = (value: unknown): value is Record<string, unknown> => {
  return !!value && typeof value === 'object' && !Array.isArray(value)
}

const getRecord = (value: unknown, key: string) => {
  if (!isRecord(value)) return undefined

  const child = value[key]
  return isRecord(child) ? child : undefined
}

const getRecordArray = (value: unknown, key: string) => {
  if (!isRecord(value)) return []

  const child = value[key]
  return Array.isArray(child) ? child.filter(isRecord) : []
}

const getStringArray = (value: unknown) => {
  return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : []
}

const getI18nValue = (value: object | null | undefined, key: string) => {
  return value ? getString(Object.entries(value).find(([itemKey]) => itemKey === key)?.[1]) : ''
}

const normalizeI18nObject = (
  value: object | null | undefined,
  fallback = '',
): PluginDeclaration['label'] => {
  const en = getI18nValue(value, 'en_US') || getI18nValue(value, 'en-US') || fallback
  const zhHans = getI18nValue(value, 'zh_Hans') || getI18nValue(value, 'zh-Hans') || en
  const ja = getI18nValue(value, 'ja_JP') || getI18nValue(value, 'ja-JP') || en
  const ptBr = getI18nValue(value, 'pt_BR') || getI18nValue(value, 'pt-BR') || en

  return {
    'en-US': en,
    'zh-Hans': zhHans,
    'zh-Hant': en,
    'pt-BR': ptBr,
    'es-ES': en,
    'fr-FR': en,
    'de-DE': en,
    'ja-JP': ja,
    'ko-KR': en,
    'ru-RU': en,
    'it-IT': en,
    'th-TH': en,
    'uk-UA': en,
    'vi-VN': en,
    'ro-RO': en,
    'pl-PL': en,
    'hi-IN': en,
    'tr-TR': en,
    'fa-IR': en,
    'sl-SI': en,
    'id-ID': en,
    'nl-NL': en,
    'ar-TN': en,
    'lo-LA': en,
    'az-AZ': en,
    en_US: en,
    zh_Hans: zhHans,
    ja_JP: ja,
    pt_BR: ptBr,
  }
}

const normalizePluginCategory = (
  category: PluginInstallationItemResponse['declaration']['category'],
): PluginCategoryEnum => {
  switch (category) {
    case PluginCategoryEnum.tool:
      return PluginCategoryEnum.tool
    case PluginCategoryEnum.model:
      return PluginCategoryEnum.model
    case PluginCategoryEnum.datasource:
      return PluginCategoryEnum.datasource
    case PluginCategoryEnum.trigger:
      return PluginCategoryEnum.trigger
    case PluginCategoryEnum.agent:
      return PluginCategoryEnum.agent
    case PluginCategoryEnum.extension:
      return PluginCategoryEnum.extension
  }
  return PluginCategoryEnum.extension
}

const normalizePluginSource = (source: PluginInstallationItemResponse['source']): PluginSource => {
  switch (source) {
    case PluginSource.github:
      return PluginSource.github
    case PluginSource.marketplace:
      return PluginSource.marketplace
    case PluginSource.local:
      return PluginSource.local
    case PluginSource.debugging:
      return PluginSource.debugging
  }
  return PluginSource.marketplace
}

const normalizePluginMeta = (meta: Record<string, unknown>): MetaData => {
  return {
    repo: getString(meta.repo),
    version: getString(meta.version),
    package: getString(meta.package),
  }
}

const normalizeToolCredentialOption = (
  option: Record<string, unknown>,
): NonNullable<
  NonNullable<PluginDeclaration['tool']>['credentials_schema'][number]['options']
>[number] => ({
  label: normalizeI18nObject(getRecord(option, 'label'), getString(option.value)),
  value: getString(option.value),
})

const normalizeToolCredential = (
  credential: Record<string, unknown>,
): NonNullable<PluginDeclaration['tool']>['credentials_schema'][number] => ({
  name: getString(credential.name),
  label: normalizeI18nObject(getRecord(credential, 'label'), getString(credential.name)),
  help: credential.help === null ? null : normalizeI18nObject(getRecord(credential, 'help')),
  placeholder: normalizeI18nObject(getRecord(credential, 'placeholder')),
  type: getString(credential.type),
  required: getBoolean(credential.required),
  default: getString(credential.default),
  options: getRecordArray(credential, 'options').map(normalizeToolCredentialOption),
})

const normalizePluginToolDeclaration = (value: unknown): PluginDeclaration['tool'] => {
  if (!isRecord(value)) return undefined

  const identity = getRecord(value, 'identity')
  if (!identity) return undefined

  const name = getString(identity.name)

  return {
    identity: {
      author: getString(identity.author),
      name,
      description: normalizeI18nObject(getRecord(identity, 'description')),
      icon: getString(identity.icon),
      label: normalizeI18nObject(getRecord(identity, 'label'), name),
      tags: getStringArray(identity.tags),
    },
    credentials_schema: getRecordArray(value, 'credentials_schema').map(normalizeToolCredential),
  }
}

const normalizeParameterDefault = (value: unknown) => {
  if (Array.isArray(value)) return value.filter((item) => typeof item === 'string')
  if (typeof value === 'string') return value
  if (value === undefined || value === null) return undefined
  return String(value)
}

const normalizeFormType = (type: unknown): FormTypeEnum => {
  switch (type) {
    case FormTypeEnum.appSelector:
      return FormTypeEnum.appSelector
    case FormTypeEnum.boolean:
      return FormTypeEnum.boolean
    case FormTypeEnum.checkbox:
      return FormTypeEnum.checkbox
    case FormTypeEnum.dynamicSelect:
      return FormTypeEnum.dynamicSelect
    case FormTypeEnum.file:
      return FormTypeEnum.file
    case FormTypeEnum.files:
      return FormTypeEnum.files
    case FormTypeEnum.modelSelector:
      return FormTypeEnum.modelSelector
    case FormTypeEnum.multiToolSelector:
      return FormTypeEnum.multiToolSelector
    case FormTypeEnum.radio:
      return FormTypeEnum.radio
    case FormTypeEnum.secretInput:
      return FormTypeEnum.secretInput
    case FormTypeEnum.select:
      return FormTypeEnum.select
    case FormTypeEnum.textNumber:
    case 'number':
      return FormTypeEnum.textNumber
    case FormTypeEnum.textInput:
    case 'string':
    case 'array':
    case 'object':
      return FormTypeEnum.textInput
  }
  return FormTypeEnum.textInput
}

const normalizeParameterOption = (
  option: Record<string, unknown>,
): NonNullable<PluginDeclaration['trigger']['subscription_schema'][number]['options']>[number] => ({
  value: getString(option.value),
  label: normalizeI18nObject(getRecord(option, 'label'), getString(option.value)),
  icon: getString(option.icon) || undefined,
})

const normalizeParameterSchema = (
  parameter: Record<string, unknown>,
): PluginDeclaration['trigger']['subscription_schema'][number] => ({
  name: getString(parameter.name),
  label: normalizeI18nObject(getRecord(parameter, 'label'), getString(parameter.name)),
  type: normalizeFormType(parameter.type),
  auto_generate: parameter.auto_generate ?? undefined,
  template: parameter.template ?? undefined,
  scope: parameter.scope ?? undefined,
  required: getBoolean(parameter.required),
  multiple: getBoolean(parameter.multiple),
  default: normalizeParameterDefault(parameter.default),
  min: parameter.min ?? undefined,
  max: parameter.max ?? undefined,
  precision: parameter.precision ?? undefined,
  options: getRecordArray(parameter, 'options').map(normalizeParameterOption),
  description: normalizeI18nObject(getRecord(parameter, 'description')),
})

const normalizeCredentialSchema = (
  schema: Record<string, unknown>,
): PluginDeclaration['trigger']['subscription_constructor']['credentials_schema'][number] => ({
  name: getString(schema.name),
  label: normalizeI18nObject(getRecord(schema, 'label'), getString(schema.name)),
  description: normalizeI18nObject(getRecord(schema, 'description')),
  type: normalizeFormType(schema.type),
  scope: schema.scope ?? undefined,
  required: getBoolean(schema.required),
  default: schema.default ?? undefined,
  options: getRecordArray(schema, 'options').map(normalizeParameterOption),
  help: normalizeI18nObject(getRecord(schema, 'help')),
  url: getString(schema.url),
  placeholder: normalizeI18nObject(getRecord(schema, 'placeholder')),
})

const normalizeTriggerEventParameter = (
  parameter: Record<string, unknown>,
): PluginDeclaration['trigger']['events'][number]['parameters'][number] => ({
  name: getString(parameter.name),
  label: normalizeI18nObject(getRecord(parameter, 'label'), getString(parameter.name)),
  type: getString(parameter.type),
  auto_generate: parameter.auto_generate ?? undefined,
  template: parameter.template ?? undefined,
  scope: parameter.scope ?? undefined,
  required: getBoolean(parameter.required),
  multiple: getBoolean(parameter.multiple),
  default: parameter.default ?? '',
  min: getNumber(parameter.min),
  max: getNumber(parameter.max),
  precision: getNumber(parameter.precision),
  options: getRecordArray(parameter, 'options').map(normalizeParameterOption),
  description: normalizeI18nObject(getRecord(parameter, 'description')),
})

const normalizeTriggerEvent = (
  event: Record<string, unknown>,
): PluginDeclaration['trigger']['events'][number] => {
  const identity = getRecord(event, 'identity')
  const name = getString(event.name)

  return {
    name,
    identity: {
      author: getString(identity?.author),
      name: getString(identity?.name) || name,
      label: normalizeI18nObject(getRecord(identity, 'label'), name),
      provider: getString(identity?.provider) || undefined,
    },
    description: normalizeI18nObject(getRecord(event, 'description'), name),
    parameters: getRecordArray(event, 'parameters').map(normalizeTriggerEventParameter),
    output_schema: getRecord(event, 'output_schema') ?? {},
  }
}

const createEmptyTrigger = (name: string): PluginDeclaration['trigger'] => ({
  events: [],
  identity: {
    author: '',
    name,
    label: normalizeI18nObject(undefined, name),
    description: normalizeI18nObject(undefined),
    icon: '',
    tags: [],
  },
  subscription_constructor: {
    credentials_schema: [],
    oauth_schema: {
      client_schema: [],
      credentials_schema: [],
    },
    parameters: [],
  },
  subscription_schema: [],
})

const normalizePluginTriggerDeclaration = (
  value: unknown,
  fallbackName: string,
): PluginDeclaration['trigger'] => {
  if (!isRecord(value)) return createEmptyTrigger(fallbackName)

  const identity = getRecord(value, 'identity')
  const subscriptionConstructor = getRecord(value, 'subscription_constructor')
  const oauthSchema = getRecord(subscriptionConstructor, 'oauth_schema')

  return {
    events: getRecordArray(value, 'events').map(normalizeTriggerEvent),
    identity: {
      author: getString(identity?.author),
      name: getString(identity?.name) || fallbackName,
      label: normalizeI18nObject(getRecord(identity, 'label'), fallbackName),
      description: normalizeI18nObject(getRecord(identity, 'description')),
      icon: getString(identity?.icon),
      tags: getStringArray(identity?.tags),
    },
    subscription_constructor: {
      credentials_schema: getRecordArray(subscriptionConstructor, 'credentials_schema').map(
        normalizeCredentialSchema,
      ),
      oauth_schema: {
        client_schema: getRecordArray(oauthSchema, 'client_schema').map(normalizeCredentialSchema),
        credentials_schema: getRecordArray(oauthSchema, 'credentials_schema').map(
          normalizeCredentialSchema,
        ),
      },
      parameters: getRecordArray(subscriptionConstructor, 'parameters').map(
        normalizeParameterSchema,
      ),
    },
    subscription_schema: getRecordArray(value, 'subscription_schema').map(normalizeParameterSchema),
  }
}

type InstalledPluginResponse =
  | PluginCategoryInstalledPluginResponse
  | PluginEntity
  | PluginInstallationItemResponse

const normalizePluginDeclaration = (plugin: InstalledPluginResponse): PluginDeclaration => {
  const { declaration } = plugin
  return {
    plugin_unique_identifier: plugin.plugin_unique_identifier,
    version: declaration.version,
    author: declaration.author ?? '',
    icon: declaration.icon,
    icon_dark: declaration.icon_dark ?? undefined,
    name: declaration.name,
    category: normalizePluginCategory(declaration.category),
    label: normalizeI18nObject(declaration.label, declaration.name),
    description: normalizeI18nObject(declaration.description, declaration.name),
    created_at: declaration.created_at,
    resource: declaration.resource,
    plugins: declaration.plugins,
    verified: declaration.verified ?? false,
    endpoint: isRecord(declaration.endpoint)
      ? zEndpointProviderDeclarationResponse.parse(declaration.endpoint)
      : undefined,
    tool: normalizePluginToolDeclaration(declaration.tool),
    datasource:
      declaration.datasource == null
        ? declaration.datasource
        : zDatasourceProviderEntity.parse(declaration.datasource),
    model: declaration.model,
    tags: declaration.tags ?? [],
    agent_strategy:
      declaration.agent_strategy == null
        ? declaration.agent_strategy
        : zAgentStrategyProviderEntity.parse(declaration.agent_strategy),
    meta: {
      version: getString(declaration.meta.version) || declaration.version,
      minimum_dify_version: getString(declaration.meta.minimum_dify_version) || undefined,
    },
    trigger: normalizePluginTriggerDeclaration(declaration.trigger, declaration.name),
  }
}

export const normalizeInstalledPluginDetail = (plugin: InstalledPluginResponse): PluginDetail => {
  const declaration = normalizePluginDeclaration(plugin)

  return {
    id: plugin.id,
    created_at: plugin.created_at,
    updated_at: plugin.updated_at,
    name: declaration.name,
    plugin_id: plugin.plugin_id,
    plugin_unique_identifier: plugin.plugin_unique_identifier,
    declaration,
    installation_id: plugin.id,
    tenant_id: plugin.tenant_id,
    endpoints_setups: plugin.endpoints_setups,
    endpoints_active: plugin.endpoints_active,
    version: plugin.version,
    latest_version: plugin.version,
    latest_unique_identifier: plugin.plugin_unique_identifier,
    source: normalizePluginSource(plugin.source),
    meta: normalizePluginMeta(plugin.meta),
    status: 'active',
    deprecated_reason: '',
    alternative_plugin_id: '',
  }
}

const isUnfinishedPluginTask = (task: PluginTask) =>
  task.status === TaskStatus.pending || task.status === TaskStatus.running

// Each plugin status records its task so a single status can be cleared.
const normalizeStartedPluginTask = (task: PluginInstallTask): PluginTask => ({
  ...task,
  plugins: task.plugins.map((plugin) => ({
    ...plugin,
    taskId: task.id,
  })),
})

const upsertStartedPluginTask = (
  queryClient: QueryClient,
  response: PluginInstallTaskStartResponse,
) => {
  if (!response.task) return

  const startedTask = normalizeStartedPluginTask(response.task)

  queryClient.setQueryData<PluginTaskListResponse>(usePluginTaskListKey, (previous) => {
    if (!previous) return { tasks: [startedTask] }

    const existingTaskIndex = previous.tasks.findIndex((task) => task.id === startedTask.id)
    if (existingTaskIndex === -1) return { tasks: [startedTask, ...previous.tasks] }

    return {
      tasks: previous.tasks.map((task) => (task.id === startedTask.id ? startedTask : task)),
    }
  })
}

const preserveLocalUnfinishedPluginTasks = (
  previousData: PluginTaskListResponse | undefined,
  nextData: PluginTaskListResponse,
) => {
  if (!previousData) return nextData

  const nextTaskIds = new Set(nextData.tasks.map((task) => task.id))
  const missingUnfinishedTasks = previousData.tasks.filter(
    (task) => !nextTaskIds.has(task.id) && isUnfinishedPluginTask(task),
  )
  if (!missingUnfinishedTasks.length) return nextData

  return {
    ...nextData,
    tasks: [...missingUnfinishedTasks, ...nextData.tasks],
  }
}

export const useCheckInstalled = ({
  pluginIds,
  enabled,
}: {
  pluginIds: string[]
  enabled: boolean
}) => {
  return useQuery(
    consoleQuery.workspaces.current.plugin.list.installations.ids.post.queryOptions({
      input: { body: { plugin_ids: pluginIds } },
      enabled,
      staleTime: 0,
      select: (response) => ({
        plugins: response.plugins.map(normalizeInstalledPluginDetail),
      }),
    }),
  )
}

export const useInvalidateCheckInstalled = () => {
  const queryClient = useQueryClient()
  return () => {
    queryClient.invalidateQueries({
      queryKey: consoleQuery.workspaces.current.plugin.list.installations.ids.post.key(),
    })
  }
}

const useRecommendedMarketplacePluginsKey = [NAME_SPACE, 'recommendedMarketplacePlugins']
const useRecommendedMarketplacePlugins = ({
  collection = '__recommended-plugins-tools',
  enabled = true,
  limit = 15,
}: {
  collection?: string
  enabled?: boolean
  limit?: number
} = {}) => {
  return useQuery<Plugin[]>({
    queryKey: [...useRecommendedMarketplacePluginsKey, collection, limit],
    queryFn: async () => {
      const response = await postMarketplace<{ data: { plugins: Plugin[] } }>(
        `/collections/${collection}/plugins`,
        {
          body: {
            limit,
          },
        },
      )
      return response.data.plugins.map((plugin) => getFormattedPlugin(plugin))
    },
    enabled,
    staleTime: 60 * 1000,
  })
}

export const useFeaturedToolsRecommendations = (enabled: boolean, limit = 15) => {
  const { data: plugins = [], isLoading } = useRecommendedMarketplacePlugins({
    collection: '__recommended-plugins-tools',
    enabled,
    limit,
  })

  return {
    plugins,
    isLoading,
  }
}

export const useFeaturedTriggersRecommendations = (enabled: boolean, limit = 15) => {
  const { data: plugins = [], isLoading } = useRecommendedMarketplacePlugins({
    collection: '__recommended-plugins-triggers',
    enabled,
    limit,
  })

  return {
    plugins,
    isLoading,
  }
}

type UseInstalledPluginListOptions = {
  category?: PluginCategoryEnum
  enabled?: boolean
  filters?: InstalledPluginListFilters
  gcTime?: number
  pageSize?: number
  staleTime?: number
}

type PluginCategoryListLanguage = NonNullable<
  NonNullable<GetWorkspacesCurrentPluginByCategoryListData['query']>['language']
>

type InstalledPluginListFilters = {
  language?: PluginCategoryListLanguage
  query?: string
  tags?: string[]
}

export const normalizePluginCategoryListLanguage = (locale: string): PluginCategoryListLanguage => {
  switch (locale) {
    case 'zh_Hans':
    case 'ja_JP':
    case 'pt_BR':
    case 'en_US':
      return locale
    default:
      return 'en_US'
  }
}

const getInstalledPluginCategoryListInfiniteOptions = ({
  category,
  filters,
  pageSize,
}: {
  category: PluginCategoryEnum
  filters?: InstalledPluginListFilters
  pageSize: number
}) => {
  return consoleQuery.workspaces.current.plugin.byCategory.list.get.infiniteOptions({
    input: (pageParam) => ({
      params: { category },
      query: {
        page: Number(pageParam),
        page_size: pageSize,
        ...(filters?.query ? { query: filters.query } : {}),
        ...(filters?.tags?.length ? { tags: filters.tags } : {}),
        ...(filters?.language ? { language: filters.language } : {}),
      },
    }),
    getNextPageParam: (lastPage, pages) => (lastPage.has_more ? pages.length + 1 : undefined),
    initialPageParam: 1,
  })
}

const getInstalledPluginCategoryListQueryKey = (
  category: PluginCategoryEnum,
  pageSize: number,
  filters?: InstalledPluginListFilters,
) => {
  return getInstalledPluginCategoryListInfiniteOptions({
    category,
    filters,
    pageSize,
  }).queryKey
}

export const useInstalledPluginList = (options: UseInstalledPluginListOptions = {}) => {
  const { category, enabled = true, filters, gcTime, pageSize = 100, staleTime } = options
  const categoryQuery = useInfiniteQuery({
    ...getInstalledPluginCategoryListInfiniteOptions({
      category: category ?? PluginCategoryEnum.tool,
      filters,
      pageSize,
    }),
    enabled: enabled && !!category,
    gcTime,
    staleTime,
  })
  const legacyQuery = useInfiniteQuery({
    ...consoleQuery.workspaces.current.plugin.list.get.infiniteOptions({
      input: (pageParam) => ({
        query: {
          page: Number(pageParam),
          page_size: pageSize,
        },
      }),
      getNextPageParam: (lastPage, pages) =>
        pages.length * pageSize < lastPage.total ? pages.length + 1 : undefined,
      initialPageParam: 1,
    }),
    enabled: enabled && !category,
    gcTime,
    staleTime,
  })
  const { data, error, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading, isSuccess } =
    category ? categoryQuery : legacyQuery

  const categoryData = category
    ? (data as InfiniteData<PluginCategoryListResponse, number> | undefined)
    : undefined
  const legacyData = category
    ? undefined
    : (data as InfiniteData<PluginListResponse, number> | undefined)
  const plugins: PluginDetail[] = categoryData
    ? categoryData.pages.flatMap((page) => page.plugins.map(normalizeInstalledPluginDetail))
    : (legacyData?.pages.flatMap((page) => page.plugins.map(normalizeInstalledPluginDetail)) ?? [])
  // The Built-in Tools panel still consumes its legacy Collection model. Keep the
  // API-contract boundary narrow until that presentation model is migrated.
  const builtinTools = categoryData?.pages[0]?.builtin_tools as Collection[] | undefined
  const total = legacyData?.pages[0]?.total ?? plugins.length

  return {
    data: enabled
      ? {
          plugins,
          builtin_tools: builtinTools ?? [],
          total,
        }
      : undefined,
    isLastPage: !hasNextPage,
    loadNextPage: () => {
      fetchNextPage()
    },
    isLoading,
    isFetching: isFetchingNextPage,
    error,
    isSuccess,
  }
}

export const useRemoveFilteredInstalledPluginPageOnUnmount = (
  category: PluginCategoryEnum | undefined,
  pageSize: number,
  filters?: InstalledPluginListFilters,
) => {
  const queryClient = useQueryClient()
  const hasActiveFilters = !!filters?.query || !!filters?.tags?.length

  useEffect(() => {
    if (!category || !hasActiveFilters) return

    const queryKey = getInstalledPluginCategoryListQueryKey(category, pageSize, filters)

    return () => queryClient.removeQueries({ queryKey, exact: true })
  }, [category, filters, hasActiveFilters, pageSize, queryClient])
}

export const useInvalidateInstalledPluginList = () => {
  const queryClient = useQueryClient()
  const invalidateAllBuiltInTools = () =>
    queryClient.invalidateQueries({
      queryKey: consoleQuery.workspaces.current.tools.builtin.get.queryKey(),
    })
  return (category?: PluginCategoryEnum) => {
    if (category) {
      const invalidateCategoryPluginList = queryClient.invalidateQueries({
        queryKey: consoleQuery.workspaces.current.plugin.byCategory.list.get.key({
          type: 'infinite',
          input: { params: { category } },
        }),
      })
      const invalidateCategoryInstalledIds = queryClient.invalidateQueries({
        queryKey: consoleQuery.workspaces.current.plugin.installedIds.get.key({
          type: 'query',
          input: { query: { category } },
        }),
      })

      if (category === PluginCategoryEnum.tool)
        return Promise.all([
          invalidateCategoryPluginList,
          invalidateCategoryInstalledIds,
          invalidateAllBuiltInTools(),
        ]).then(() => undefined)

      return Promise.all([invalidateCategoryPluginList, invalidateCategoryInstalledIds]).then(
        () => undefined,
      )
    }

    return Promise.all([
      queryClient.invalidateQueries({
        queryKey: consoleQuery.workspaces.current.plugin.list.get.key(),
      }),
      queryClient.invalidateQueries({
        queryKey: consoleQuery.workspaces.current.plugin.byCategory.list.get.key(),
      }),
      queryClient.invalidateQueries({
        queryKey: consoleQuery.workspaces.current.plugin.installedIds.get.key(),
      }),
      invalidateAllBuiltInTools(),
    ]).then(() => undefined)
  }
}

export const useInstallPackageFromMarketPlace = (
  options?: MutateOptions<PluginInstallTaskStartResponse, Error, string>,
) => {
  const queryClient = useQueryClient()
  return useMutation({
    ...options,
    mutationFn: (uniqueIdentifier: string) => {
      return consoleClient.workspaces.current.plugin.install.marketplace.post({
        body: { plugin_unique_identifiers: [uniqueIdentifier] },
      })
    },
    onSuccess: (data, variables, context, mutation) => {
      upsertStartedPluginTask(queryClient, data)
      options?.onSuccess?.(data, variables, context, mutation)
    },
  })
}

export const useUpdatePackageFromMarketPlace = (
  options?: MutateOptions<PluginInstallTaskStartResponse, Error, ParserMarketplaceUpgrade>,
) => {
  const queryClient = useQueryClient()
  return useMutation({
    ...options,
    mutationFn: (body: ParserMarketplaceUpgrade) => {
      return consoleClient.workspaces.current.plugin.upgrade.marketplace.post({
        body,
      })
    },
    onSuccess: (data, variables, context, mutation) => {
      upsertStartedPluginTask(queryClient, data)
      options?.onSuccess?.(data, variables, context, mutation)
    },
  })
}

export const usePluginDeclarationFromMarketPlace = (pluginUniqueIdentifier: string) => {
  return useQuery({
    queryKey: [NAME_SPACE, 'pluginDeclaration', pluginUniqueIdentifier],
    queryFn: () =>
      consoleClient.workspaces.current.plugin.marketplace.pkg.get({
        query: { plugin_unique_identifier: pluginUniqueIdentifier },
      }),
    enabled: !!pluginUniqueIdentifier,
  })
}

export const useInstallPackageFromLocal = () => {
  const queryClient = useQueryClient()
  return useMutation({
    mutationFn: (uniqueIdentifier: string) => {
      return consoleClient.workspaces.current.plugin.install.pkg.post({
        body: { plugin_unique_identifiers: [uniqueIdentifier] },
      })
    },
    onSuccess: (data) => {
      upsertStartedPluginTask(queryClient, data)
    },
  })
}

export const useInstallPackageFromGitHub = () => {
  const queryClient = useQueryClient()
  return useMutation({
    mutationFn: ({
      repoUrl,
      selectedVersion,
      selectedPackage,
      uniqueIdentifier,
    }: {
      repoUrl: string
      selectedVersion: string
      selectedPackage: string
      uniqueIdentifier: string
    }) => {
      return consoleClient.workspaces.current.plugin.install.github.post({
        body: {
          repo: repoUrl,
          version: selectedVersion,
          package: selectedPackage,
          plugin_unique_identifier: uniqueIdentifier,
        },
      })
    },
    onSuccess: (data) => {
      upsertStartedPluginTask(queryClient, data)
    },
  })
}

export const useUploadGitHub = (payload: { repo: string; version: string; package: string }) => {
  return useQuery({
    queryKey: [NAME_SPACE, 'uploadGitHub', payload],
    queryFn: () =>
      consoleClient.workspaces.current.plugin.upload.github.post({
        body: payload,
      }),
    retry: 0,
  })
}

export const useInstallOrUpdate = ({
  onSuccess,
}: {
  onSuccess?: (res: InstallStatusResponse[]) => void
}) => {
  const queryClient = useQueryClient()
  const { mutateAsync: updatePackageFromMarketPlace } = useUpdatePackageFromMarketPlace()

  return useMutation({
    mutationFn: (data: {
      payload: Dependency[]
      plugin: Plugin[]
      installedInfo: Record<string, VersionInfo>
    }) => {
      const { payload, plugin, installedInfo } = data

      return Promise.all(
        payload.map(async (item, i) => {
          try {
            const orgAndName = `${plugin[i]?.org || plugin[i]?.author}/${plugin[i]?.name}`
            const installedPayload = installedInfo[orgAndName]
            const isInstalled = !!installedPayload
            let uniqueIdentifier = ''
            let taskId = ''
            let isFinishedInstallation = false

            if (item.type === 'github') {
              const data = item as GitHubItemAndMarketPlaceDependency
              // From local bundle don't have data.value.github_plugin_unique_identifier
              uniqueIdentifier = data.value.github_plugin_unique_identifier!
              if (!uniqueIdentifier) {
                const { unique_identifier } =
                  await consoleClient.workspaces.current.plugin.upload.github.post({
                    body: {
                      repo: data.value.repo!,
                      version: data.value.release! || data.value.version!,
                      package: data.value.packages! || data.value.package!,
                    },
                  })
                uniqueIdentifier = data.value.github_plugin_unique_identifier! || unique_identifier
                // has the same version, but not installed
                if (uniqueIdentifier === installedPayload?.uniqueIdentifier) {
                  return {
                    status: TaskStatus.success,
                    taskId: '',
                    uniqueIdentifier: '',
                  }
                }
              }
              if (!isInstalled) {
                const response = await consoleClient.workspaces.current.plugin.install.github.post({
                  body: {
                    repo: data.value.repo!,
                    version: data.value.release! || data.value.version!,
                    package: data.value.packages! || data.value.package!,
                    plugin_unique_identifier: uniqueIdentifier,
                  },
                })
                upsertStartedPluginTask(queryClient, response)
                const { task_id, all_installed } = response
                taskId = task_id
                isFinishedInstallation = all_installed
              }
            }
            if (item.type === 'marketplace') {
              const data = item as GitHubItemAndMarketPlaceDependency
              uniqueIdentifier =
                data.value.marketplace_plugin_unique_identifier! ||
                (plugin[i]?.latest_package_identifier ?? '') ||
                (plugin[i]?.plugin_id ?? '')
              if (uniqueIdentifier === installedPayload?.uniqueIdentifier) {
                return {
                  status: TaskStatus.success,
                  taskId: '',
                  uniqueIdentifier: '',
                }
              }
              if (!isInstalled) {
                const response =
                  await consoleClient.workspaces.current.plugin.install.marketplace.post({
                    body: {
                      plugin_unique_identifiers: [uniqueIdentifier],
                    },
                  })
                upsertStartedPluginTask(queryClient, response)
                const { task_id, all_installed } = response
                taskId = task_id
                isFinishedInstallation = all_installed
              }
            }
            if (item.type === 'package') {
              const data = item as PackageDependency
              uniqueIdentifier = data.value.unique_identifier
              if (uniqueIdentifier === installedPayload?.uniqueIdentifier) {
                return {
                  status: TaskStatus.success,
                  taskId: '',
                  uniqueIdentifier: '',
                }
              }
              if (!isInstalled) {
                const response = await consoleClient.workspaces.current.plugin.install.pkg.post({
                  body: {
                    plugin_unique_identifiers: [uniqueIdentifier],
                  },
                })
                upsertStartedPluginTask(queryClient, response)
                const { task_id, all_installed } = response
                taskId = task_id
                isFinishedInstallation = all_installed
              }
            }
            if (isInstalled) {
              if (item.type === 'package') {
                await uninstallPlugin(installedPayload.installedId, { preserveCredentials: true })
                const response = await consoleClient.workspaces.current.plugin.install.pkg.post({
                  body: {
                    plugin_unique_identifiers: [uniqueIdentifier],
                  },
                })
                upsertStartedPluginTask(queryClient, response)
                const { task_id, all_installed } = response
                taskId = task_id
                isFinishedInstallation = all_installed
              } else {
                const response = await updatePackageFromMarketPlace({
                  original_plugin_unique_identifier: installedPayload?.uniqueIdentifier,
                  new_plugin_unique_identifier: uniqueIdentifier,
                })
                const { task_id, all_installed } = response
                taskId = task_id
                isFinishedInstallation = all_installed
              }
            }
            if (isFinishedInstallation) {
              return {
                status: TaskStatus.success,
                taskId: '',
                uniqueIdentifier: '',
              }
            } else {
              return {
                status: TaskStatus.running,
                taskId,
                uniqueIdentifier,
              }
            }
          } catch {
            return Promise.resolve({ status: TaskStatus.failed, taskId: '', uniqueIdentifier: '' })
          }
        }),
      )
    },
    onSuccess,
  })
}

export const useDebugKey = () => {
  return useQuery({
    queryKey: [NAME_SPACE, 'debugKey'],
    queryFn: () => consoleClient.workspaces.current.plugin.debuggingKey.get(),
  })
}

type PluginAutoUpgradeSettingsResponse = {
  category: PluginCategoryEnum
  auto_upgrade: AutoUpdateConfig
}

type MarketplacePluginInfoRequest = {
  organization?: string
  plugin?: string
  version?: string
}

const useReferenceSettingKey = [NAME_SPACE, 'referenceSettings']
const usePluginPermissionSettingsKey = [...useReferenceSettingKey, 'permission']
const usePluginAutoUpgradeSettingsKey = [...useReferenceSettingKey, 'autoUpgrade']
const pluginAutoUpgradeSettingsQueryKey = (category: PluginCategoryEnum) => [
  ...usePluginAutoUpgradeSettingsKey,
  category,
]

const areStringArraysEqual = (left: string[], right: string[]) => {
  return left.length === right.length && left.every((value, index) => value === right[index])
}

const arePermissionsEqual = (left: Permissions | undefined, right: Permissions | undefined) => {
  return (
    left?.install_permission === right?.install_permission &&
    left?.debug_permission === right?.debug_permission
  )
}

const areAutoUpgradeSettingsEqual = (
  left: AutoUpdateConfig | undefined,
  right: AutoUpdateConfig | undefined,
) => {
  return (
    left?.strategy_setting === right?.strategy_setting &&
    left?.upgrade_time_of_day === right?.upgrade_time_of_day &&
    left?.upgrade_mode === right?.upgrade_mode &&
    areStringArraysEqual(left?.exclude_plugins ?? [], right?.exclude_plugins ?? []) &&
    areStringArraysEqual(left?.include_plugins ?? [], right?.include_plugins ?? [])
  )
}

// legacy plugin permission
// export const hasPluginPermission = (permission: PermissionType | undefined, isAdmin: boolean) => {
//   if (!permission)
//     return false

//   if (permission === PermissionType.noOne)
//     return false

//   if (permission === PermissionType.everyone)
//     return true

//   return isAdmin
// }

export const usePluginPermissionSettings = () => {
  return useQuery({
    queryKey: usePluginPermissionSettingsKey,
    queryFn: () => consoleClient.workspaces.current.plugin.permission.fetch.get(),
  })
}

export const usePluginAutoUpgradeSettings = (category: PluginCategoryEnum) => {
  return useQuery({
    queryKey: pluginAutoUpgradeSettingsQueryKey(category),
    queryFn: () =>
      consoleClient.workspaces.current.plugin.autoUpgrade.fetch.get({ query: { category } }),
    staleTime: 60 * 1000,
  })
}

export const useInvalidateReferenceSettings = () => {
  const queryClient = useQueryClient()
  return () => {
    queryClient.invalidateQueries({
      queryKey: useReferenceSettingKey,
    })
  }
}

export const useMutationPluginPermissionSettings = ({
  onSuccess,
}: {
  onSuccess?: () => void
} = {}) => {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: (payload: Permissions) => {
      return consoleClient.workspaces.current.plugin.permission.change.post({ body: payload })
    },
    onMutate: async (payload) => {
      await queryClient.cancelQueries({ queryKey: usePluginPermissionSettingsKey })
      const previousPermission = queryClient.getQueryData<Permissions>(
        usePluginPermissionSettingsKey,
      )
      const hadPreviousPermission = previousPermission !== undefined

      queryClient.setQueryData(usePluginPermissionSettingsKey, payload)

      return { previousPermission, hadPreviousPermission }
    },
    onError: (_error, _payload, context) => {
      if (context?.hadPreviousPermission)
        queryClient.setQueryData(usePluginPermissionSettingsKey, context.previousPermission)
      else queryClient.removeQueries({ queryKey: usePluginPermissionSettingsKey })
    },
    onSuccess: () => {
      onSuccess?.()
    },
  })
}

export const useMutationPluginAutoUpgradeSettings = ({
  category,
  onSuccess,
}: {
  category: PluginCategoryEnum
  onSuccess?: () => void
}) => {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: (payload: AutoUpdateConfig) => {
      return consoleClient.workspaces.current.plugin.autoUpgrade.change.post({
        body: {
          category,
          auto_upgrade: payload,
        },
      })
    },
    onMutate: async (payload) => {
      const queryKey = pluginAutoUpgradeSettingsQueryKey(category)
      await queryClient.cancelQueries({ queryKey })
      const previousAutoUpgrade =
        queryClient.getQueryData<PluginAutoUpgradeSettingsResponse>(queryKey)
      const hadPreviousAutoUpgrade = previousAutoUpgrade !== undefined

      queryClient.setQueryData(queryKey, {
        category,
        auto_upgrade: payload,
      } satisfies PluginAutoUpgradeSettingsResponse)

      return { queryKey, previousAutoUpgrade, hadPreviousAutoUpgrade }
    },
    onError: (_error, _payload, context) => {
      // Roll back the category this save started for; the caller may have moved to another one.
      if (!context) return
      if (context.hadPreviousAutoUpgrade)
        queryClient.setQueryData(context.queryKey, context.previousAutoUpgrade)
      else queryClient.removeQueries({ queryKey: context.queryKey })
    },
    onSuccess: () => {
      onSuccess?.()
    },
  })
}

export const useMutationReferenceSettings = ({
  category,
  currentReferenceSetting,
  onSuccess,
}: {
  category: PluginCategoryEnum
  currentReferenceSetting?: ReferenceSetting
  onSuccess?: () => void
}) => {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: (payload: ReferenceSetting) => {
      const mutations: Array<Promise<unknown>> = []

      if (!arePermissionsEqual(payload.permission, currentReferenceSetting?.permission))
        mutations.push(
          consoleClient.workspaces.current.plugin.permission.change.post({
            body: payload.permission,
          }),
        )

      if (
        !areAutoUpgradeSettingsEqual(payload.auto_upgrade, currentReferenceSetting?.auto_upgrade)
      ) {
        mutations.push(
          consoleClient.workspaces.current.plugin.autoUpgrade.change.post({
            body: {
              category,
              auto_upgrade: payload.auto_upgrade,
            },
          }),
        )
      }

      return Promise.all(mutations)
    },
    onMutate: async (payload) => {
      const shouldUpdatePermission = !arePermissionsEqual(
        payload.permission,
        currentReferenceSetting?.permission,
      )
      const shouldUpdateAutoUpgrade = !areAutoUpgradeSettingsEqual(
        payload.auto_upgrade,
        currentReferenceSetting?.auto_upgrade,
      )
      const autoUpgradeQueryKey = pluginAutoUpgradeSettingsQueryKey(category)

      await Promise.all([
        shouldUpdatePermission
          ? queryClient.cancelQueries({ queryKey: usePluginPermissionSettingsKey })
          : Promise.resolve(),
        shouldUpdateAutoUpgrade
          ? queryClient.cancelQueries({ queryKey: autoUpgradeQueryKey })
          : Promise.resolve(),
      ])

      const previousPermission = queryClient.getQueryData<Permissions>(
        usePluginPermissionSettingsKey,
      )
      const previousAutoUpgrade =
        queryClient.getQueryData<PluginAutoUpgradeSettingsResponse>(autoUpgradeQueryKey)
      const hadPreviousPermission = previousPermission !== undefined
      const hadPreviousAutoUpgrade = previousAutoUpgrade !== undefined

      if (shouldUpdatePermission)
        queryClient.setQueryData(usePluginPermissionSettingsKey, payload.permission)

      if (shouldUpdateAutoUpgrade) {
        queryClient.setQueryData(autoUpgradeQueryKey, {
          category,
          auto_upgrade: payload.auto_upgrade,
        } satisfies PluginAutoUpgradeSettingsResponse)
      }

      return {
        previousPermission,
        previousAutoUpgrade,
        hadPreviousPermission,
        hadPreviousAutoUpgrade,
        shouldUpdatePermission,
        shouldUpdateAutoUpgrade,
      }
    },
    onError: (_error, _payload, context) => {
      if (context?.shouldUpdatePermission && context.hadPreviousPermission)
        queryClient.setQueryData(usePluginPermissionSettingsKey, context.previousPermission)
      else if (context?.shouldUpdatePermission)
        queryClient.removeQueries({ queryKey: usePluginPermissionSettingsKey })

      if (context?.shouldUpdateAutoUpgrade && context.hadPreviousAutoUpgrade)
        queryClient.setQueryData(
          pluginAutoUpgradeSettingsQueryKey(category),
          context.previousAutoUpgrade,
        )
      else if (context?.shouldUpdateAutoUpgrade)
        queryClient.removeQueries({ queryKey: pluginAutoUpgradeSettingsQueryKey(category) })
    },
    onSuccess,
  })
}

export const useRemoveAutoUpgrade = () => {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: (payload: { plugin_id: string; category: PluginCategoryEnum }) => {
      return consoleClient.workspaces.current.plugin.autoUpgrade.exclude.post({ body: payload })
    },
    onSuccess: (_data, payload) => {
      queryClient.invalidateQueries({
        queryKey: pluginAutoUpgradeSettingsQueryKey(payload.category),
      })
    },
  })
}

export const useFetchPluginsInMarketPlaceByIds = (
  unique_identifiers: string[],
  options?: QueryOptions<{ data: PluginsFromMarketplaceResponse }>,
) => {
  return useQuery({
    ...options,
    queryKey: [NAME_SPACE, 'fetchPluginsInMarketPlaceByIds', unique_identifiers],
    queryFn: () =>
      postMarketplace<{ data: PluginsFromMarketplaceResponse }>('/plugins/identifier/batch', {
        body: {
          unique_identifiers,
        },
      }),
    enabled: unique_identifiers?.filter((i) => !!i).length > 0,
    retry: 0,
  })
}

export const useFetchPluginsInMarketPlaceByInfo = (infos: MarketplacePluginInfoRequest[]) => {
  return useQuery({
    queryKey: [NAME_SPACE, 'fetchPluginsInMarketPlaceByInfo', infos],
    queryFn: () =>
      postMarketplace<{ data: PluginsFromMarketplaceByInfoResponse }>('/plugins/versions/batch', {
        body: {
          plugin_tuples: infos.map((info) => ({
            org: info.organization,
            name: info.plugin,
            version: info.version,
          })),
        },
      }),
    enabled: infos?.filter((i) => !!i).length > 0,
    retry: 0,
  })
}

export const usePluginTaskList = (category?: PluginCategoryEnum | string) => {
  const initializedRef = useRef(false)
  const queryClient = useQueryClient()
  const workspacePermissionKeys = useAtomValue(workspacePermissionKeysAtom)
  const canManagement = hasPermission(workspacePermissionKeys, 'plugin.install')
  const { refreshPluginList } = useRefreshPluginList()
  const query = useQuery<PluginTaskListResponse>({
    enabled: canManagement,
    queryKey: usePluginTaskListKey,
    queryFn: () =>
      consoleClient.workspaces.current.plugin.tasks
        .get({ query: { page: 1, page_size: 100 } })
        .then(({ tasks }) => ({ tasks: tasks.map(normalizeStartedPluginTask) })),
    structuralSharing: (previousData, nextData) =>
      preserveLocalUnfinishedPluginTasks(
        previousData as PluginTaskListResponse | undefined,
        nextData as PluginTaskListResponse,
      ),
    refetchInterval: (lastQuery) => {
      const lastData = lastQuery.state.data
      const taskDone = lastData?.tasks.every(
        (task) => task.status === TaskStatus.success || task.status === TaskStatus.failed,
      )
      return taskDone ? false : 5000
    },
  })
  const { data, isFetched, isRefetching, refetch } = query

  useEffect(() => {
    // After first fetch, refresh plugin list each time all tasks are done
    // Skip initialization period, because the query cache is not updated yet
    if (!initializedRef.current) {
      initializedRef.current = true
      return
    }

    if (isRefetching) return

    const lastData = cloneDeep(data)
    const taskDone = lastData?.tasks.every(
      (task) => task.status === TaskStatus.success || task.status === TaskStatus.failed,
    )
    const taskAllFailed = lastData?.tasks.every((task) => task.status === TaskStatus.failed)
    if (taskDone && lastData?.tasks.length && !taskAllFailed)
      refreshPluginList(
        category ? { category: category as PluginCategoryEnum } : undefined,
        !category,
      )
  }, [category, data, isRefetching, refreshPluginList])

  const handleRefetch = useCallback(() => {
    refetch()
  }, [refetch])

  const handleInstallTaskStart = useCallback(
    (response: PluginInstallTaskStartResponse) => {
      if (response.all_installed) return

      upsertStartedPluginTask(queryClient, response)
      refetch()
    },
    [queryClient, refetch],
  )

  return {
    data,
    pluginTasks: data?.tasks || [],
    isFetched,
    handleRefetch,
    handleInstallTaskStart,
  }
}

export const useMutationClearTaskPlugin = () => {
  return useMutation({
    mutationFn: ({ taskId, pluginId }: { taskId: string; pluginId: string }) => {
      return consoleClient.workspaces.current.plugin.tasks.byTaskId.delete.byIdentifier.post({
        params: { task_id: taskId, identifier: pluginId },
      })
    },
  })
}

export const usePluginManifestInfo = (pluginUID: string) => {
  return useQuery({
    enabled: !!pluginUID,
    queryKey: [NAME_SPACE, 'manifest', pluginUID],
    queryFn: () =>
      getMarketplace<{ data: { plugin: PluginInfoFromMarketPlace; version: { version: string } } }>(
        `/plugins/${pluginUID}`,
      ),
    retry: 0,
  })
}

// Untranslated labels fall back to en_US, matching renderI18nObject. Dynamic options have no
// display conditions.
const toDynamicOption = ({ value, label, icon }: PluginParameterOption): FormOption => ({
  value,
  label: {
    en_US: label.en_US,
    zh_Hans: label.zh_Hans ?? label.en_US,
    ...(label.ja_JP != null && { ja_JP: label.ja_JP }),
    ...(label.pt_BR != null && { pt_BR: label.pt_BR }),
  },
  icon: icon ?? undefined,
  show_on: [],
})

export const useFetchDynamicOptions = (
  plugin_id: string,
  provider: string,
  action: string,
  parameter: string,
  // The backend requires a provider type; callers without one render tool options.
  provider_type: 'tool' | 'trigger' = 'tool',
  extra?: Record<string, unknown>,
) => {
  return useMutation({
    mutationFn: () =>
      consoleClient.workspaces.current.plugin.parameters.dynamicOptions
        .get({
          query: {
            plugin_id,
            provider,
            action,
            parameter,
            provider_type,
            ...extra,
          },
        })
        .then(({ options }) => ({ options: options.map(toDynamicOption) })),
  })
}