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.

13.8 KB
Raw Blame
import type { AppMode } from '@dify/contracts/api/console/apps/types.gen'
import type { Features as FeaturesData } from '@/app/components/base/features/types'
import type { TriggerNodeType } from '@/app/components/workflow/types'
import type { IOtherOptions } from '@/service/base'
import type { FetchWorkflowDraftResponse } from '@/types/workflow'
import { noop } from 'es-toolkit/function'
import { isInstalledAppPath } from '@/app/components/explore/installed-app/routes'
import { TriggerType } from '@/app/components/workflow/header/test-run-menu'
import { WorkflowRunningStatus } from '@/app/components/workflow/types'
import { toast } from '@/app/notifications'
import { handleStream, post } from '@/service/base'
import { ContentType } from '@/service/fetch'

export type HandleRunOptions = {
  mode?: TriggerType
  scheduleNodeId?: string
  webhookNodeId?: string
  pluginNodeId?: string
  allNodeIds?: string[]
}

type DebuggableTriggerType = Exclude<TriggerType, typeof TriggerType.UserInput>

type AppDetailLike = {
  id?: string
  mode?: AppMode
}

type TTSParamsLike = {
  token?: string
  appId?: string
}

type ListeningStateActions = {
  setWorkflowRunningData: (
    data:
      | ReturnType<typeof createRunningWorkflowState>
      | ReturnType<typeof createFailedWorkflowState>
      | ReturnType<typeof createStoppedWorkflowState>,
  ) => void
  setIsListening: (value: boolean) => void
  setShowVariableInspectPanel: (value: boolean) => void
  setListeningTriggerType: (value: TriggerNodeType | null) => void
  setListeningTriggerNodeIds: (value: string[]) => void
  setListeningTriggerIsAll: (value: boolean) => void
  setListeningTriggerNodeId: (value: string | null) => void
}

type TriggerDebugRunnerOptions = {
  debugType: DebuggableTriggerType
  url: string
  requestBody: unknown
  baseSseOptions: IOtherOptions
  controllerTarget: Record<string, unknown>
  setAbortController: (controller: AbortController | null) => void
  clearAbortController: () => void
  clearListeningState: () => void
  setWorkflowRunningData: ListeningStateActions['setWorkflowRunningData']
}

const controllerKeyMap: Record<DebuggableTriggerType, string> = {
  [TriggerType.Webhook]: '__webhookDebugAbortController',
  [TriggerType.Plugin]: '__pluginDebugAbortController',
  [TriggerType.All]: '__allTriggersDebugAbortController',
  [TriggerType.Schedule]: '__scheduleDebugAbortController',
}

const debugLabelMap: Record<DebuggableTriggerType, string> = {
  [TriggerType.Webhook]: 'Webhook',
  [TriggerType.Plugin]: 'Plugin',
  [TriggerType.All]: 'All',
  [TriggerType.Schedule]: 'Schedule',
}

const createRunningWorkflowState = () => {
  return {
    result: {
      status: WorkflowRunningStatus.Running,
      inputs_truncated: false,
      process_data_truncated: false,
      outputs_truncated: false,
    },
    tracing: [],
    resultText: '',
    reasoningContent: {},
    reasoningFinished: false,
  }
}

const createStoppedWorkflowState = () => {
  return {
    result: {
      status: WorkflowRunningStatus.Stopped,
      inputs_truncated: false,
      process_data_truncated: false,
      outputs_truncated: false,
    },
    tracing: [],
    resultText: '',
  }
}

const createFailedWorkflowState = (error: string) => {
  return {
    result: {
      status: WorkflowRunningStatus.Failed,
      error,
      inputs_truncated: false,
      process_data_truncated: false,
      outputs_truncated: false,
    },
    tracing: [],
  }
}

export const buildRunHistoryUrl = (appDetail?: AppDetailLike) => {
  return appDetail?.mode === 'advanced-chat'
    ? `/apps/${appDetail.id}/advanced-chat/workflow-runs`
    : `/apps/${appDetail?.id}/workflow-runs`
}

export const resolveWorkflowRunUrl = (
  appDetail: AppDetailLike | undefined,
  runMode: TriggerType,
  isInWorkflowDebug: boolean,
) => {
  if (
    runMode === TriggerType.Plugin ||
    runMode === TriggerType.Webhook ||
    runMode === TriggerType.Schedule
  ) {
    if (!appDetail?.id) {
      console.error('handleRun: missing app id for trigger plugin run')
      return ''
    }

    return `/apps/${appDetail.id}/workflows/draft/trigger/run`
  }

  if (runMode === TriggerType.All) {
    if (!appDetail?.id) {
      console.error('handleRun: missing app id for trigger run all')
      return ''
    }

    return `/apps/${appDetail.id}/workflows/draft/trigger/run-all`
  }

  if (appDetail?.mode === 'advanced-chat')
    return `/apps/${appDetail.id}/advanced-chat/workflows/draft/run`

  if (isInWorkflowDebug && appDetail?.id) return `/apps/${appDetail.id}/workflows/draft/run`

  return ''
}

export const buildWorkflowRunRequestBody = (
  runMode: TriggerType,
  resolvedParams: Record<string, unknown>,
  options?: HandleRunOptions,
) => {
  if (runMode === TriggerType.Schedule) return { node_id: options?.scheduleNodeId }

  if (runMode === TriggerType.Webhook) return { node_id: options?.webhookNodeId }

  if (runMode === TriggerType.Plugin) return { node_id: options?.pluginNodeId }

  if (runMode === TriggerType.All) return { node_ids: options?.allNodeIds }

  return resolvedParams
}

export const validateWorkflowRunRequest = (runMode: TriggerType, options?: HandleRunOptions) => {
  if (runMode === TriggerType.Schedule && !options?.scheduleNodeId)
    return 'handleRun: schedule trigger run requires node id'

  if (runMode === TriggerType.Webhook && !options?.webhookNodeId)
    return 'handleRun: webhook trigger run requires node id'

  if (runMode === TriggerType.Plugin && !options?.pluginNodeId)
    return 'handleRun: plugin trigger run requires node id'

  if (runMode === TriggerType.All && !options?.allNodeIds && options?.allNodeIds?.length === 0)
    return 'handleRun: all trigger run requires node ids'

  return ''
}

export const isDebuggableTriggerType = (runMode: TriggerType): runMode is DebuggableTriggerType => {
  return (
    runMode === TriggerType.Schedule ||
    runMode === TriggerType.Webhook ||
    runMode === TriggerType.Plugin ||
    runMode === TriggerType.All
  )
}

const buildListeningTriggerNodeIds = (
  runMode: DebuggableTriggerType,
  options?: HandleRunOptions,
) => {
  if (runMode === TriggerType.All) return options?.allNodeIds ?? []

  if (runMode === TriggerType.Webhook && options?.webhookNodeId) return [options.webhookNodeId]

  if (runMode === TriggerType.Schedule && options?.scheduleNodeId) return [options.scheduleNodeId]

  if (runMode === TriggerType.Plugin && options?.pluginNodeId) return [options.pluginNodeId]

  return []
}

export const applyRunningStateForMode = (
  actions: ListeningStateActions,
  runMode: TriggerType,
  options?: HandleRunOptions,
) => {
  if (isDebuggableTriggerType(runMode)) {
    actions.setIsListening(true)
    actions.setShowVariableInspectPanel(true)
    actions.setListeningTriggerIsAll(runMode === TriggerType.All)
    actions.setListeningTriggerNodeIds(buildListeningTriggerNodeIds(runMode, options))
    actions.setWorkflowRunningData(createRunningWorkflowState())
    return
  }

  actions.setIsListening(false)
  actions.setListeningTriggerType(null)
  actions.setListeningTriggerNodeId(null)
  actions.setListeningTriggerNodeIds([])
  actions.setListeningTriggerIsAll(false)
  actions.setWorkflowRunningData(createRunningWorkflowState())
}

export const clearListeningState = (
  actions: Pick<
    ListeningStateActions,
    | 'setIsListening'
    | 'setListeningTriggerType'
    | 'setListeningTriggerNodeId'
    | 'setListeningTriggerNodeIds'
    | 'setListeningTriggerIsAll'
  >,
) => {
  actions.setIsListening(false)
  actions.setListeningTriggerType(null)
  actions.setListeningTriggerNodeId(null)
  actions.setListeningTriggerNodeIds([])
  actions.setListeningTriggerIsAll(false)
}

export const applyStoppedState = (
  actions: Pick<
    ListeningStateActions,
    | 'setWorkflowRunningData'
    | 'setIsListening'
    | 'setShowVariableInspectPanel'
    | 'setListeningTriggerType'
    | 'setListeningTriggerNodeId'
  >,
) => {
  actions.setWorkflowRunningData(createStoppedWorkflowState())
  actions.setIsListening(false)
  actions.setListeningTriggerType(null)
  actions.setListeningTriggerNodeId(null)
  actions.setShowVariableInspectPanel(true)
}

export const clearWindowDebugControllers = (controllerTarget: Record<string, unknown>) => {
  delete controllerTarget.__webhookDebugAbortController
  delete controllerTarget.__pluginDebugAbortController
  delete controllerTarget.__scheduleDebugAbortController
  delete controllerTarget.__allTriggersDebugAbortController
}

export const buildTTSConfig = (resolvedParams: TTSParamsLike, pathname: string) => {
  let ttsUrl = ''
  let ttsIsPublic = false

  if (resolvedParams.token) {
    ttsUrl = '/text-to-audio'
    ttsIsPublic = true
  } else if (resolvedParams.appId) {
    if (isInstalledAppPath(pathname))
      ttsUrl = `/installed-apps/${resolvedParams.appId}/text-to-audio`
    else ttsUrl = `/apps/${resolvedParams.appId}/text-to-audio`
  }

  return {
    ttsUrl,
    ttsIsPublic,
  }
}

export const mapPublishedWorkflowFeatures = (
  publishedWorkflow: FetchWorkflowDraftResponse,
): FeaturesData => {
  return {
    opening: {
      enabled:
        !!publishedWorkflow.features.opening_statement ||
        !!publishedWorkflow.features.suggested_questions.length,
      opening_statement: publishedWorkflow.features.opening_statement,
      suggested_questions: publishedWorkflow.features.suggested_questions,
    },
    suggested: publishedWorkflow.features.suggested_questions_after_answer,
    text2speech: publishedWorkflow.features.text_to_speech,
    speech2text: publishedWorkflow.features.speech_to_text,
    citation: publishedWorkflow.features.retriever_resource,
    moderation: publishedWorkflow.features.sensitive_word_avoidance,
    file: publishedWorkflow.features.file_upload,
  }
}

export const normalizePublishedWorkflowNodes = (publishedWorkflow: FetchWorkflowDraftResponse) => {
  return publishedWorkflow.graph.nodes.map((node) => ({
    ...node,
    selected: false,
    data: {
      ...node.data,
      selected: false,
    },
  }))
}

const waitWithAbort = (signal: AbortSignal, delay: number) =>
  new Promise<void>((resolve) => {
    const timer = window.setTimeout(resolve, delay)
    signal.addEventListener(
      'abort',
      () => {
        clearTimeout(timer)
        resolve()
      },
      { once: true },
    )
  })

export const runTriggerDebug = async ({
  debugType,
  url,
  requestBody,
  baseSseOptions,
  controllerTarget,
  setAbortController,
  clearAbortController,
  clearListeningState,
  setWorkflowRunningData,
}: TriggerDebugRunnerOptions) => {
  const controller = new AbortController()
  setAbortController(controller)

  const controllerKey = controllerKeyMap[debugType]
  controllerTarget[controllerKey] = controller

  const debugLabel = debugLabelMap[debugType]

  const poll = async (): Promise<void> => {
    try {
      const response = await post<Response>(
        url,
        {
          body: requestBody,
          signal: controller.signal,
        },
        {
          needAllResponseContent: true,
          silent: true,
        },
      )

      if (controller.signal.aborted) return

      if (!response) {
        const message = `${debugLabel} debug request failed`
        toast.error(message)
        clearAbortController()
        return
      }

      const contentType = response.headers.get('content-type') || ''

      if (contentType.includes(ContentType.json)) {
        let data: Record<string, unknown> | null = null
        try {
          data = (await response.json()) as Record<string, unknown>
        } catch (jsonError) {
          console.error(
            `handleRun: ${debugLabel.toLowerCase()} debug response parse error`,
            jsonError,
          )
          toast.error(`${debugLabel} debug request failed`)
          clearAbortController()
          clearListeningState()
          return
        }

        if (controller.signal.aborted) return

        if (data?.status === 'waiting') {
          const delay = Number(data.retry_in) || 2000
          await waitWithAbort(controller.signal, delay)
          if (controller.signal.aborted) return
          await poll()
          return
        }

        const errorMessage =
          typeof data?.message === 'string' ? data.message : `${debugLabel} debug failed`
        toast.error(errorMessage)
        clearAbortController()
        setWorkflowRunningData(createFailedWorkflowState(errorMessage))
        clearListeningState()
        return
      }

      clearListeningState()
      handleStream(
        response,
        baseSseOptions.onData ?? noop,
        baseSseOptions.onCompleted,
        baseSseOptions.onThought,
        baseSseOptions.onMessageEnd,
        baseSseOptions.onMessageReplace,
        baseSseOptions.onFile,
        baseSseOptions.onWorkflowStarted,
        baseSseOptions.onWorkflowFinished,
        baseSseOptions.onNodeStarted,
        baseSseOptions.onNodeFinished,
        baseSseOptions.onIterationStart,
        baseSseOptions.onIterationNext,
        baseSseOptions.onIterationFinish,
        baseSseOptions.onLoopStart,
        baseSseOptions.onLoopNext,
        baseSseOptions.onLoopFinish,
        baseSseOptions.onNodeRetry,
        baseSseOptions.onParallelBranchStarted,
        baseSseOptions.onParallelBranchFinished,
        baseSseOptions.onTextChunk,
        baseSseOptions.onTTSChunk,
        baseSseOptions.onTTSEnd,
        baseSseOptions.onTextReplace,
        baseSseOptions.onAgentLog,
        baseSseOptions.onHumanInputRequired,
        baseSseOptions.onHumanInputFormFilled,
        baseSseOptions.onHumanInputFormTimeout,
        baseSseOptions.onWorkflowPaused,
        baseSseOptions.onDataSourceNodeProcessing,
        baseSseOptions.onDataSourceNodeCompleted,
        baseSseOptions.onDataSourceNodeError,
      )
    } catch (error) {
      if (controller.signal.aborted) return

      if (error instanceof Error) {
        const errorMessage = error.message
        toast.error(errorMessage)
        clearAbortController()
        setWorkflowRunningData(createFailedWorkflowState(errorMessage))
      }

      clearListeningState()
    }
  }

  await poll()
}