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 {
AIProviderName,
LocalesEnum,
spreadIfDefined,
} from '@activepieces/core-utils';
import {
ErrorHandlingOptionsParam,
PieceMetadataModel,
PieceMetadataModelSummary,
} from '@activepieces/pieces-framework';
import {
FlowAction,
FlowActionType,
flowStructureUtil,
Step,
FlowTriggerType,
FlowTrigger,
PieceAudienceFilter,
StepOutput,
StepRunResponse,
ProjectAIProvider,
} from '@activepieces/shared';
import { t } from 'i18next';
import { piecesApi } from '../api/pieces-api';
import {
PieceStepMetadata,
PrimitiveStepMetadata,
StepMetadata,
StepMetadataWithActionOrTriggerOrAgentDisplayName,
} from '../types';
export const stepUtils = {
hasAiRouterProvider(providers: ProjectAIProvider[] | undefined): boolean {
return (providers ?? []).some(
(provider) =>
provider.provider === AIProviderName.ACTIVEPIECES ||
provider.provider === AIProviderName.OPENROUTER,
);
},
coreActionsMetadata(): PrimitiveStepMetadata[] {
const coreStepMetadata = buildCoreStepMetadata();
return [
coreStepMetadata[FlowActionType.CODE],
coreStepMetadata[FlowActionType.LOOP_ON_ITEMS],
coreStepMetadata[FlowActionType.ROUTER],
coreStepMetadata[FlowActionType.AI_ROUTER],
];
},
getKeys(
step: FlowAction | FlowTrigger,
locale: LocalesEnum,
): (string | undefined)[] {
const isPieceStep =
step.type === FlowActionType.PIECE || step.type === FlowTriggerType.PIECE;
const pieceName = isPieceStep ? step.settings.pieceName : undefined;
const pieceVersion = isPieceStep ? step.settings.pieceVersion : undefined;
const customLogoUrl = isPieceStep
? 'customLogoUrl' in step
? (step.customLogoUrl as string)
: undefined
: undefined;
return [pieceName, pieceVersion, customLogoUrl, locale, step.type];
},
async getMetadata(
step: FlowAction | FlowTrigger,
locale: LocalesEnum,
): Promise<StepMetadataWithActionOrTriggerOrAgentDisplayName> {
const customLogoUrl =
'customLogoUrl' in step ? step.customLogoUrl : undefined;
switch (step.type) {
case FlowActionType.ROUTER:
case FlowActionType.AI_ROUTER:
case FlowActionType.LOOP_ON_ITEMS:
case FlowActionType.CODE:
case FlowTriggerType.EMPTY:
return {
...buildCoreStepMetadata()[step.type],
...spreadIfDefined('logoUrl', customLogoUrl),
actionOrTriggerOrAgentDisplayName: '',
actionOrTriggerOrAgentDescription: '',
};
case FlowActionType.PIECE:
case FlowTriggerType.PIECE: {
const piece = await piecesApi.get({
name: step.settings.pieceName,
version: step.settings.pieceVersion,
locale,
audience: PieceAudienceFilter.ALL,
});
const latestPieceVersion = await piecesApi.get({
name: step.settings.pieceName,
version: undefined,
locale,
audience: PieceAudienceFilter.ALL,
});
piece.logoUrl = latestPieceVersion.logoUrl;
const metadata = stepUtils.mapPieceToMetadata({
piece,
type: step.type === FlowActionType.PIECE ? 'action' : 'trigger',
});
const actionOrTrigger =
step.type === FlowActionType.PIECE
? piece.actions[step.settings.actionName!]
: piece.triggers[step.settings.triggerName!];
return {
...metadata,
errorHandlingOptions: mapErrorHandlingOptions(piece, step),
actionOrTriggerOrAgentDescription: actionOrTrigger?.description ?? '',
actionOrTriggerOrAgentDisplayName: actionOrTrigger?.displayName ?? '',
};
}
}
},
mapPieceToMetadata({
piece,
type,
}: {
piece: PieceMetadataModelSummary | PieceMetadataModel;
type: 'action' | 'trigger';
}): Omit<PieceStepMetadata, 'stepDisplayName'> {
return {
displayName: piece.displayName,
logoUrl: piece.logoUrl,
description: piece.description,
type: type === 'action' ? FlowActionType.PIECE : FlowTriggerType.PIECE,
pieceType: piece.pieceType,
pieceName: piece.name,
pieceVersion: piece.version,
categories: piece.categories ?? [],
packageType: piece.packageType,
auth: piece.auth,
};
},
getAgentRunId(output: StepOutput | StepRunResponse | undefined | null) {
if (!output) {
return undefined;
}
return 'output' in output &&
'agentRunId' in (output.output as { agentRunId: string })
? (output.output as { agentRunId: string }).agentRunId
: undefined;
},
};
export function extractPieceNamesAndCoreMetadata(
steps: ReturnType<typeof flowStructureUtil.getAllSteps>,
excludeCore: boolean,
): { pieceNames: string[]; coreMetadata: StepMetadata[] } {
const pieceNamesSet = new Set<string>();
const coreMetadata: StepMetadata[] = [];
const coreStepMetadata = excludeCore ? undefined : buildCoreStepMetadata();
for (const step of steps) {
if (
step.type === FlowActionType.PIECE ||
step.type === FlowTriggerType.PIECE
) {
pieceNamesSet.add(step.settings.pieceName);
} else if (coreStepMetadata) {
const coreMeta = coreStepMetadata[step.type];
if (coreMeta) {
coreMetadata.push(coreMeta);
}
}
}
return { pieceNames: Array.from(pieceNamesSet), coreMetadata };
}
function buildCoreStepMetadata(): Record<
Exclude<FlowActionType, FlowActionType.PIECE> | FlowTriggerType.EMPTY,
PrimitiveStepMetadata
> {
return {
[FlowActionType.CODE]: {
displayName: t('Code'),
logoUrl: 'https://cdn.activepieces.com/pieces/new-core/code.svg',
description: t('Powerful Node.js & TypeScript code with npm'),
type: FlowActionType.CODE,
},
[FlowActionType.LOOP_ON_ITEMS]: {
displayName: t('Loop on Items'),
logoUrl: 'https://cdn.activepieces.com/pieces/new-core/loop.svg',
description: t('Iterate over a list of items'),
type: FlowActionType.LOOP_ON_ITEMS,
},
[FlowActionType.ROUTER]: {
displayName: t('Router'),
logoUrl: 'https://cdn.activepieces.com/pieces/new-core/router.svg',
description: t('Split your flow into branches depending on condition(s)'),
type: FlowActionType.ROUTER,
},
[FlowActionType.AI_ROUTER]: {
displayName: t('AI Router'),
logoUrl: 'https://cdn.activepieces.com/pieces/ai_router.png',
description: t(
'Ask one question and Jev, an evaluation model, picks the route',
),
type: FlowActionType.AI_ROUTER,
},
[FlowTriggerType.EMPTY]: {
displayName: t('Empty Trigger'),
logoUrl: 'https://cdn.activepieces.com/pieces/new-core/empty-trigger.svg',
description: t('Empty Trigger'),
type: FlowTriggerType.EMPTY,
},
};
}
function mapErrorHandlingOptions(
piece: PieceMetadataModel,
step: Step,
): ErrorHandlingOptionsParam {
if (flowStructureUtil.isTrigger(step.type)) {
return {
continueOnFailure: {
hide: true,
},
retryOnFailure: {
hide: true,
},
};
}
const selectedAction =
step.type === FlowActionType.PIECE
? piece.actions[step.settings.actionName!]
: null;
const errorHandlingOptions = selectedAction?.errorHandlingOptions;
if (errorHandlingOptions) {
return errorHandlingOptions;
}
return {
continueOnFailure: {
hide: false,
defaultValue: false,
},
retryOnFailure: {
hide: false,
defaultValue: false,
},
};
}