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.

2.9 KB
Raw Blame
import { atom } from 'jotai'
import { selectAtom } from 'jotai/utils'
import { taskGraphIsActive, taskIsActive, taskVersionIsAfter } from '../model'
import { backgroundTasksAtom, baseTasksAtom, documentsAtom } from '../state/queries'
import { taskRuntimeStateAtom } from '../state/scoped'
import { transitionTaskRuntimeState } from './runtime-state'
import { effectiveDocumentTasks, resolveDocumentTask } from './snapshot'
import { dismissedBackgroundTaskIdsAtom } from './storage'

const observedTasksAtom = selectAtom(taskRuntimeStateAtom, (state) => state.observedTasks)

export const runtimeBaseTasksAtom = atom((get) => {
  const tasks = new Map(get(observedTasksAtom))
  for (const task of get(baseTasksAtom)) {
    const observed = tasks.get(task.id)
    if (!observed || !taskVersionIsAfter(observed.updatedAt, task.updatedAt))
      tasks.set(task.id, task)
  }
  return [...tasks.values()]
})

export const applyTaskRuntimeEventAtom = atom(
  null,
  (get, set, event: Parameters<typeof transitionTaskRuntimeState>[1]) => {
    const transition = transitionTaskRuntimeState(get(taskRuntimeStateAtom), event)
    let state = transition.state
    const tasks = effectiveDocumentTasks({
      baseTasks: get(runtimeBaseTasksAtom),
      streamActiveOverrideVersions: state.streamActiveOverrideVersions,
      taskOverrides: state.overrides,
      terminalTaskPins: state.terminalPins,
    })
    for (const task of tasks) {
      if (!taskIsActive(task))
        state = transitionTaskRuntimeState(state, { taskId: task.id, type: 'task-inactive' }).state
    }
    set(taskRuntimeStateAtom, state)
    return { ...transition, state }
  },
)

export const effectiveTasksAtom = atom((get) => {
  const runtimeState = get(taskRuntimeStateAtom)

  return effectiveDocumentTasks({
    baseTasks: get(runtimeBaseTasksAtom),
    streamActiveOverrideVersions: runtimeState.streamActiveOverrideVersions,
    taskOverrides: runtimeState.overrides,
    terminalTaskPins: runtimeState.terminalPins,
  })
})

export const activeTasksAtom = atom((get) => get(effectiveTasksAtom).filter(taskIsActive))

export const documentTaskByDocumentAtom = atom((get) => {
  const snapshots = new Map(get(effectiveTasksAtom).map((task) => [task.id, task]))
  return new Map(
    get(documentsAtom).flatMap((document) => {
      const task = resolveDocumentTask(
        document,
        document.latestTask ? snapshots.get(document.latestTask.id) : undefined,
      )
      return task ? [[document.id, task] as const] : []
    }),
  )
})

export const drawerTasksAtom = atom((get) => {
  const effectiveTaskById = new Map(get(effectiveTasksAtom).map((task) => [task.id, task]))
  const dismissedTaskIds = get(dismissedBackgroundTaskIdsAtom)

  return get(backgroundTasksAtom)
    .map((task) => effectiveTaskById.get(task.id) ?? task)
    .filter(
      (task) => taskIsActive(task) || taskGraphIsActive(task) || !dismissedTaskIds.has(task.id),
    )
})