AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
import { isNil, parseToJsonIfPossible, tryCatch } from '@activepieces/core-utils'
import { EngineOperationType, EngineResponseStatus, ExecuteTriggerResponse, FlowVersion, PieceTrigger, StreamStepProgress, TriggerHookType, WebhookJobData, WorkerJobType } from '@activepieces/shared'
import { workerSettings } from '../../config/worker-settings'
import { FireAndForgetJobResult, JobContext, JobHandler, JobResultKind } from '../types'
import { summarizeEngineError } from '../utils/engine-error-summary'
import { isSandboxTimeout } from '../utils/sandbox-helpers'
import { recordTriggerRun } from '../utils/trigger-run-recorder'
import { getAppWebhookUrl, getWebhookUrl } from '../utils/webhook-url'
function getAppWebhookDetails(flowVersion: FlowVersion, publicApiUrl: string, appWebhookSecretsJson: string): { appWebhookUrl?: string, webhookSecret?: string | Record<string, string> } {
const trigger = flowVersion.trigger as PieceTrigger
const pieceName = trigger?.settings?.pieceName
if (isNil(pieceName)) {
return {}
}
const secrets = parseToJsonIfPossible(appWebhookSecretsJson) as Record<string, { webhookSecret: string | Record<string, string> }> | undefined
const webhookSecret = secrets?.[pieceName]?.webhookSecret
const pieceUrlName = pieceName.replace('@activepieces/piece-', '')
return {
appWebhookUrl: getAppWebhookUrl(publicApiUrl, pieceUrlName),
webhookSecret,
}
}
export const executeWebhookJob: JobHandler<WebhookJobData, FireAndForgetJobResult> = {
jobType: WorkerJobType.EXECUTE_WEBHOOK,
async execute(ctx: JobContext, data: WebhookJobData): Promise<FireAndForgetJobResult> {
const settings = workerSettings.getSettings()
const timeoutInSeconds = settings.TRIGGER_TIMEOUT_SECONDS
const resolved = await ctx.resolver.resolve({ platformId: data.platformId, internalApiUrl: ctx.internalApiUrl, engineToken: ctx.engineToken, flow: { id: data.flowId, versionId: data.flowVersionIdToRun, projectId: data.projectId } })
if (resolved.kind === 'flow-not-found') {
ctx.log.info({ flowVersion: { id: data.flowVersionIdToRun } }, 'Flow version not found for webhook, skipping')
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK }
}
if (resolved.kind === 'disabled') {
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK }
}
// resolved.kind === 'ready' — flowVersion is guaranteed present when flow: is passed to resolve
if (isNil(resolved.flowVersion)) {
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.INTERNAL_ERROR }
}
const flowVersion: FlowVersion = resolved.flowVersion
const { appWebhookUrl, webhookSecret } = getAppWebhookDetails(flowVersion, ctx.publicApiUrl, settings.APP_WEBHOOK_SECRETS)
const webhookLogFields = {
webhook: { requestId: data.requestId },
flow: { id: data.flowId },
flowVersion: { id: flowVersion.id },
project: { id: data.projectId },
}
let realExecutionStarted = false
const { data: execResult, error } = await tryCatch(async () => {
if (data.saveSampleData) {
const sampleResult = await ctx.runtime.execute({
workerIndex: ctx.workerIndex,
log: ctx.log,
operationType: EngineOperationType.EXECUTE_TRIGGER_HOOK,
operation: {
hookType: TriggerHookType.RUN,
flowVersion,
webhookUrl: getWebhookUrl(ctx.publicApiUrl, data.flowId, true),
triggerPayload: data.payload,
test: true,
projectId: data.projectId,
platformId: data.platformId,
engineToken: ctx.engineToken,
internalApiUrl: ctx.internalApiUrl,
publicApiUrl: ctx.publicApiUrl,
timeoutInSeconds,
appWebhookUrl,
webhookSecret,
},
timeoutInSeconds,
provision: resolved.provision,
})
if (sampleResult.status === EngineResponseStatus.OK) {
const sampleTriggerResult = sampleResult.response as ExecuteTriggerResponse<TriggerHookType.RUN>
if (sampleTriggerResult.output.length > 0) {
await ctx.apiClient.savePayloads({
flowId: data.flowId,
flowVersionId: flowVersion.id,
projectId: data.projectId,
payloads: sampleTriggerResult.output,
})
}
}
}
if (!data.execute) {
return null
}
realExecutionStarted = true
const result = await ctx.runtime.execute({
workerIndex: ctx.workerIndex,
log: ctx.log,
operationType: EngineOperationType.EXECUTE_TRIGGER_HOOK,
operation: {
hookType: TriggerHookType.RUN,
flowVersion,
webhookUrl: getWebhookUrl(ctx.publicApiUrl, data.flowId),
triggerPayload: data.payload,
test: false,
projectId: data.projectId,
platformId: data.platformId,
engineToken: ctx.engineToken,
internalApiUrl: ctx.internalApiUrl,
publicApiUrl: ctx.publicApiUrl,
timeoutInSeconds,
appWebhookUrl,
webhookSecret,
},
timeoutInSeconds,
provision: resolved.provision,
})
return result
})
if (error) {
if (realExecutionStarted) {
await recordTriggerRun({ apiClient: ctx.apiClient, log: ctx.log, flowVersion, platformId: data.platformId, status: EngineResponseStatus.INTERNAL_ERROR })
}
if (isSandboxTimeout(error)) {
if (data.execute) {
ctx.log.error(webhookLogFields, 'Webhook execution timed out in sandbox, no flow run created')
}
else {
ctx.log.warn(webhookLogFields, 'Webhook execution timed out in sandbox')
}
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK }
}
throw error
}
if (isNil(execResult)) {
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK }
}
if (execResult.status === EngineResponseStatus.OK) {
const triggerResult = execResult.response as ExecuteTriggerResponse<TriggerHookType.RUN>
if (triggerResult.output.length > 0) {
await ctx.apiClient.submitPayloads({
flowVersionId: flowVersion.id,
projectId: data.projectId,
payloads: triggerResult.output,
httpRequestId: data.requestId,
environment: data.runEnvironment,
streamStepProgress: StreamStepProgress.NONE,
parentRunId: data.parentRunId,
failParentOnFailure: data.failParentOnFailure,
})
}
else {
ctx.log.info(webhookLogFields, 'Webhook trigger returned no payloads, skipping run creation')
}
}
else {
const failureFields = { ...webhookLogFields, engine: { status: execResult.status, error: summarizeEngineError({ error: execResult.error }) } }
if (execResult.status === EngineResponseStatus.USER_FAILURE) {
ctx.log.warn(failureFields, 'Webhook trigger hook failed, no flow run created')
}
else {
ctx.log.error(failureFields, 'Webhook trigger hook failed, no flow run created')
}
}
await recordTriggerRun({ apiClient: ctx.apiClient, log: ctx.log, flowVersion, platformId: data.platformId, status: execResult.status, error: execResult.error })
return { kind: JobResultKind.FIRE_AND_FORGET, status: EngineResponseStatus.OK, logs: execResult.logs }
},
}