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.

4.8 KB
Raw Blame
import type {
  DifyResponse,
  DifyStream,
  JsonObject,
  QueryParams,
  SuccessResponse,
} from '../types/common'
import type { WorkflowRunRequest, WorkflowRunResponse } from '../types/workflow'
import { DifyClient } from './base'
import { ensureNonEmptyString, ensureOptionalInt, ensureOptionalString } from './validation'

export class WorkflowClient extends DifyClient {
  run(
    request: WorkflowRunRequest,
  ): Promise<DifyResponse<WorkflowRunResponse> | DifyStream<WorkflowRunResponse>>
  run(
    inputs: JsonObject,
    user: string,
    stream?: boolean,
  ): Promise<DifyResponse<WorkflowRunResponse> | DifyStream<WorkflowRunResponse>>
  run(
    inputOrRequest: WorkflowRunRequest | JsonObject,
    user?: string,
    stream = false,
  ): Promise<DifyResponse<WorkflowRunResponse> | DifyStream<WorkflowRunResponse>> {
    let payload: WorkflowRunRequest
    let shouldStream = stream

    if (user === undefined && 'user' in (inputOrRequest as WorkflowRunRequest)) {
      payload = inputOrRequest as WorkflowRunRequest
      shouldStream = payload.response_mode === 'streaming'
    } else {
      ensureNonEmptyString(user, 'user')
      payload = {
        inputs: inputOrRequest,
        user,
        response_mode: stream ? 'streaming' : 'blocking',
      }
    }

    ensureNonEmptyString(payload.user, 'user')

    if (shouldStream) {
      return this.http.requestStream<WorkflowRunResponse>({
        method: 'POST',
        path: '/workflows/run',
        data: payload,
      })
    }

    return this.http.request<WorkflowRunResponse>({
      method: 'POST',
      path: '/workflows/run',
      data: payload,
    })
  }

  runById(
    workflowId: string,
    request: WorkflowRunRequest,
  ): Promise<DifyResponse<WorkflowRunResponse> | DifyStream<WorkflowRunResponse>> {
    ensureNonEmptyString(workflowId, 'workflowId')
    ensureNonEmptyString(request.user, 'user')
    if (request.response_mode === 'streaming') {
      return this.http.requestStream<WorkflowRunResponse>({
        method: 'POST',
        path: `/workflows/${workflowId}/run`,
        data: request,
      })
    }
    return this.http.request<WorkflowRunResponse>({
      method: 'POST',
      path: `/workflows/${workflowId}/run`,
      data: request,
    })
  }

  getRun(workflowRunId: string): Promise<DifyResponse<WorkflowRunResponse>> {
    ensureNonEmptyString(workflowRunId, 'workflowRunId')
    return this.http.request({
      method: 'GET',
      path: `/workflows/run/${workflowRunId}`,
    })
  }

  stop(taskId: string, user: string): Promise<DifyResponse<SuccessResponse>> {
    ensureNonEmptyString(taskId, 'taskId')
    ensureNonEmptyString(user, 'user')
    return this.http.request<SuccessResponse>({
      method: 'POST',
      path: `/workflows/tasks/${taskId}/stop`,
      data: { user },
    })
  }

  /**
   * Get workflow execution logs with filtering options.
   *
   * Note: The backend API filters by `createdByEndUserSessionId` (end user session ID)
   * or `createdByAccount` (account ID), not by a generic `user` parameter.
   */
  getLogs(options?: {
    keyword?: string
    status?: string
    createdAtBefore?: string
    createdAtAfter?: string
    createdByEndUserSessionId?: string
    createdByAccount?: string
    page?: number
    limit?: number
    startTime?: string
    endTime?: string
  }): Promise<DifyResponse<JsonObject>> {
    if (options?.keyword) {
      ensureOptionalString(options.keyword, 'keyword')
    }
    if (options?.status) {
      ensureOptionalString(options.status, 'status')
    }
    if (options?.createdAtBefore) {
      ensureOptionalString(options.createdAtBefore, 'createdAtBefore')
    }
    if (options?.createdAtAfter) {
      ensureOptionalString(options.createdAtAfter, 'createdAtAfter')
    }
    if (options?.createdByEndUserSessionId) {
      ensureOptionalString(options.createdByEndUserSessionId, 'createdByEndUserSessionId')
    }
    if (options?.createdByAccount) {
      ensureOptionalString(options.createdByAccount, 'createdByAccount')
    }
    if (options?.startTime) {
      ensureOptionalString(options.startTime, 'startTime')
    }
    if (options?.endTime) {
      ensureOptionalString(options.endTime, 'endTime')
    }
    ensureOptionalInt(options?.page, 'page')
    ensureOptionalInt(options?.limit, 'limit')

    const createdAtAfter = options?.createdAtAfter ?? options?.startTime
    const createdAtBefore = options?.createdAtBefore ?? options?.endTime

    const query: QueryParams = {
      keyword: options?.keyword,
      status: options?.status,
      created_at__before: createdAtBefore,
      created_at__after: createdAtAfter,
      created_by_end_user_session_id: options?.createdByEndUserSessionId,
      created_by_account: options?.createdByAccount,
      page: options?.page,
      limit: options?.limit,
    }

    return this.http.request({
      method: 'GET',
      path: '/workflows/logs',
      query,
    })
  }
}