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 { ActivepiecesAiBilling, aiChargeFor, ActivepiecesError, AIProviderName, ErrorCode, isNil, observedProviderFetch, ProviderOutcomeReporter, spreadIfDefined } from '@activepieces/core-utils';
import { CloudflareGatewayMetadata, createCloudflareGatewayModel, createImageModel, createLanguageModel } from '@activepieces/ai-providers';
import { ACTIVEPIECES_IMAGE_TIERS, AI_PROVIDER_CAPABILITIES, AiProviderCredentials, aiProviderUtils, getEffectiveProviderAndModel } from '@activepieces/shared';
import { anthropic } from '@ai-sdk/anthropic'
import { createAzure } from '@ai-sdk/azure'
import { createGoogleGenerativeAI, google } from '@ai-sdk/google'
import { createOpenAI, openai } from '@ai-sdk/openai'
import { SharedV3ProviderOptions } from '@ai-sdk/provider'
import { createOpenRouter, OpenRouterChatSettings } from '@openrouter/ai-sdk-provider'
import { EmbeddingModel, generateText, ImageModel, LanguageModel, ToolSet } from 'ai'
import { billedEmbeddingModel, billedLanguageModel } from './activepieces-ai-cost'
import { keyHealthReporterFor } from './ai-provider-key-health'
import { modelTierCatalog } from './model-tier-catalog'
const DEFAULT_WEB_SEARCH_RESULTS = 5
const MIN_OPENROUTER_WEB_SEARCH_RESULTS = 1
const MAX_OPENROUTER_WEB_SEARCH_RESULTS = 10
const REPORT_WHAT_THE_CALL_COST = { usage: { include: true } } as const
const EMBEDDING_REPORTS_WHAT_IT_COST = { extraBody: { usage: { include: true } } } as const
const NATIVE_WEB_SEARCH_TOOLS: Record<string, (params: NativeWebSearchToolParams) => ToolSet> = {
[AIProviderName.ANTHROPIC]: ({ options }) => ({
web_search: anthropic.tools.webSearch_20250305({
maxUses: options.maxUses ?? DEFAULT_WEB_SEARCH_RESULTS,
...spreadIfDefined('userLocation', buildUserLocation(options)),
...spreadIfDefined('allowedDomains', allowedSearchDomains(options)),
...spreadIfDefined('blockedDomains', blockedSearchDomains(options)),
}),
}),
[AIProviderName.OPENAI]: ({ options }) => ({
web_search_preview: openai.tools.webSearchPreview({
...spreadIfDefined('searchContextSize', options.searchContextSize),
...spreadIfDefined('userLocation', buildUserLocation(options)),
}),
}),
[AIProviderName.GOOGLE]: () => ({ google_search: google.tools.googleSearch({}) }),
}
function supportsWebSearch(provider: AIProviderName): boolean {
return AI_PROVIDER_CAPABILITIES[provider].webSearch !== undefined
}
function buildWebSearchTools({ provider, model, options = {} }: {
provider: AIProviderName
model?: string
options?: WebSearchOptions
}): ToolSet {
const { provider: searchProvider } = getEffectiveProviderAndModel({ provider, model })
return NATIVE_WEB_SEARCH_TOOLS[searchProvider ?? provider]?.({ options }) ?? {}
}
function buildWebSearchToolsOrThrow({ provider, model, webSearchEnabled, options = {} }: {
provider: AIProviderName
model?: string
webSearchEnabled: boolean
options?: WebSearchOptions
}): ToolSet {
if (!webSearchEnabled) {
return {}
}
const { provider: searchProvider } = getEffectiveProviderAndModel({ provider, model })
const resolvedProvider = searchProvider ?? provider
if (AI_PROVIDER_CAPABILITIES[provider].webSearch === 'plugin') {
return {}
}
if (isNil(NATIVE_WEB_SEARCH_TOOLS[resolvedProvider])) {
throw new Error(`Provider ${resolvedProvider} is not supported for web search`)
}
return buildWebSearchTools({ provider, model, options })
}
async function searchWeb({ credentials, modelId, providerConfigId, billing, turnAlreadyCharged, usageOnly, system, prompt, abortSignal }: {
credentials: AiProviderCredentials
modelId: string
providerConfigId?: string
billing: ActivepiecesAiBilling | null
turnAlreadyCharged?: boolean
usageOnly?: boolean
system: string
prompt: string
abortSignal: AbortSignal
}): Promise<WebSearchResult> {
const { text, sources } = await generateText({
model: createModel({ credentials, modelId, billing, turnAlreadyCharged, usageOnly, webSearchEnabled: true, ...spreadIfDefined('providerConfigId', providerConfigId) }),
tools: buildWebSearchTools({ provider: credentials.provider, model: modelId }),
system,
prompt,
abortSignal,
})
const pages = sources.flatMap((source) => source.sourceType === 'url' ? [{ url: source.url, title: source.title ?? '' }] : [])
return { text, sources: [...new Map(pages.map((page) => [page.url, page])).values()] }
}
function buildUserLocation(options: WebSearchOptions): UserLocation | undefined {
const location = {
...spreadIfDefined('city', options.userLocationCity),
...spreadIfDefined('region', options.userLocationRegion),
...spreadIfDefined('country', options.userLocationCountry),
...spreadIfDefined('timezone', options.userLocationTimezone),
}
return Object.keys(location).length === 0 ? undefined : { type: 'approximate', ...location }
}
function allowedSearchDomains(options: WebSearchOptions): string[] | undefined {
const domains = options.allowedDomains?.map(({ domain }) => domain) ?? []
return domains.length === 0 ? undefined : domains
}
function blockedSearchDomains(options: WebSearchOptions): string[] | undefined {
if (!isNil(allowedSearchDomains(options))) {
return undefined
}
const domains = options.blockedDomains?.map(({ domain }) => domain) ?? []
return domains.length === 0 ? undefined : domains
}
function openRouterModelSettings({ provider, webSearchEnabled, options }: {
provider: AIProviderName
webSearchEnabled: boolean
options?: WebSearchOptions
}): OpenRouterChatSettings | undefined {
const settings: OpenRouterChatSettings = {
...(reportsItsCost(provider) ? REPORT_WHAT_THE_CALL_COST : {}),
...(webSearchEnabled && AI_PROVIDER_CAPABILITIES[provider].webSearch === 'plugin'
? { plugins: [{ id: 'web' as const, max_results: openRouterWebSearchResults(options) }] }
: {}),
}
return Object.keys(settings).length === 0 ? undefined : settings
}
function reportsItsCost(provider: AIProviderName): boolean {
return provider === AIProviderName.ACTIVEPIECES || provider === AIProviderName.OPENROUTER
}
function openRouterWebSearchResults(options?: WebSearchOptions): number {
return Math.min(
Math.max(options?.maxUses ?? DEFAULT_WEB_SEARCH_RESULTS, MIN_OPENROUTER_WEB_SEARCH_RESULTS),
MAX_OPENROUTER_WEB_SEARCH_RESULTS,
)
}
function managedModelIds(): string[] {
return [
...aiProviderUtils.managedChatModelIds(),
...(['flow', 'chat'] as const).flatMap((surface) => modelTierCatalog.current(surface).tiers.map((tier) => tier.modelId)),
]
}
function managedImageModelIds(): string[] {
return ACTIVEPIECES_IMAGE_TIERS.map((tier) => tier.modelId)
}
function assertManagedModelAllowed({ provider, modelId, image, adminChosenModelId }: { provider: AIProviderName, modelId: string, image: boolean, adminChosenModelId?: string }): void {
const allowed = image ? [...managedImageModelIds(), ...(isNil(adminChosenModelId) ? [] : [adminChosenModelId])] : managedModelIds()
if (provider !== AIProviderName.ACTIVEPIECES || allowed.includes(modelId)) {
return
}
const message = `The model "${modelId}" is not available on Activepieces AI credits. Choose one of the listed models or connect your own AI provider key.`
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message },
}, message)
}
function createModel({ credentials, modelId, metadata, flowStep, billing, turnAlreadyCharged, usageOnly, webSearchEnabled = false, webSearchOptions, platformId, providerConfigId, imageGeneration = false, adminChosenImageModelId }: {
credentials: AiProviderCredentials
modelId: string
metadata?: ChatModelMetadata
flowStep?: FlowStepMetadata
billing: ActivepiecesAiBilling | null
turnAlreadyCharged?: boolean
usageOnly?: boolean
webSearchEnabled?: boolean
webSearchOptions?: WebSearchOptions
platformId?: string
providerConfigId?: string
imageGeneration?: boolean
adminChosenImageModelId?: string
}): LanguageModel {
assertManagedModelAllowed({ provider: credentials.provider, modelId, image: imageGeneration, ...spreadIfDefined('adminChosenModelId', adminChosenImageModelId) })
const model = buildModel({ credentials, modelId, metadata, flowStep, webSearchEnabled, webSearchOptions, onOutcome: keyHealthReporterFor({ platformId, providerConfigId }) })
return billedLanguageModel({
model,
provider: credentials.provider,
providerConfigId,
modelId,
billing,
charge: aiChargeFor({ credentials, turnAlreadyCharged, usageOnly }),
})
}
function buildModel({ credentials, modelId, metadata, flowStep, webSearchEnabled, webSearchOptions, onOutcome }: {
credentials: AiProviderCredentials
modelId: string
metadata?: ChatModelMetadata
flowStep?: FlowStepMetadata
webSearchEnabled: boolean
webSearchOptions?: WebSearchOptions
onOutcome?: ProviderOutcomeReporter
}): LanguageModel {
const { provider } = credentials
if (credentials.provider === AIProviderName.CLOUDFLARE_GATEWAY) {
return createCloudflareGatewayModel({
credentials,
modelId,
routing: isNil(flowStep) ? 'compat' : 'submodel',
...spreadIfDefined('metadata', cloudflareGatewayMetadata(flowStep)),
...spreadIfDefined('onOutcome', onOutcome),
})
}
return createLanguageModel({
credentials,
modelId,
options: {
openRouterSettings: openRouterModelSettings({ provider, webSearchEnabled, options: webSearchOptions }),
mistralViaOpenRouter: isNil(flowStep),
...spreadIfDefined('extraHeaders', flowStepMetadataHeaders(flowStep) ?? managedProviderMetadataHeaders({ provider, metadata })),
...spreadIfDefined('onOutcome', onOutcome),
},
})
}
function cloudflareGatewayMetadata(flowStep?: FlowStepMetadata): CloudflareGatewayMetadata | undefined {
if (isNil(flowStep)) {
return undefined
}
return { projectId: flowStep.projectId, flowId: flowStep.flowId, runId: flowStep.runId }
}
function flowStepMetadataHeaders(flowStep?: FlowStepMetadata): Record<string, string> | undefined {
if (isNil(flowStep)) {
return undefined
}
return {
'x-ap-project-id': flowStep.projectId,
'x-ap-platform-id': flowStep.platformId,
'x-ap-flow-id': flowStep.flowId,
'x-ap-run-id': flowStep.runId,
}
}
function createModelForImages({ credentials, modelId, flowStep, adminChosenImageModelId }: {
credentials: AiProviderCredentials
modelId: string
flowStep?: FlowStepMetadata
adminChosenImageModelId?: string
}): ImageModel | undefined {
assertManagedModelAllowed({ provider: credentials.provider, modelId, image: true, ...spreadIfDefined('adminChosenModelId', adminChosenImageModelId) })
if (credentials.provider === AIProviderName.CLOUDFLARE_GATEWAY) {
return createCloudflareGatewayModel({
credentials,
modelId,
isImage: true,
routing: isNil(flowStep) ? 'compat' : 'submodel',
...spreadIfDefined('metadata', cloudflareGatewayMetadata(flowStep)),
})
}
return createImageModel({ credentials, modelId })
}
function toStorageEmbedding(embedding: number[]): number[] {
if (embedding.length < EMBEDDING_DIMENSIONS) {
throw new Error(`This embedding model returns ${embedding.length} dimensions, fewer than the ${EMBEDDING_DIMENSIONS} a knowledge base stores`)
}
const truncated = embedding.slice(0, EMBEDDING_DIMENSIONS)
const magnitude = Math.sqrt(truncated.reduce((sum, value) => sum + value * value, 0))
return magnitude === 0 ? truncated : truncated.map((value) => value / magnitude)
}
function createEmbeddingModel({ credentials, modelId, billing, platformId, providerConfigId }: {
credentials: AiProviderCredentials
modelId?: string
billing: ActivepiecesAiBilling | null
platformId?: string
providerConfigId?: string
}): { model: EmbeddingModel, providerOptions: SharedV3ProviderOptions } {
const embeddingModelId = modelId ?? AI_PROVIDER_CAPABILITIES[credentials.provider].defaultEmbeddingModel
if (isNil(embeddingModelId)) {
throw new Error(`Provider ${credentials.provider} does not support knowledge base search`)
}
const built = buildEmbeddingModel({ credentials, embeddingModelId, fetch: observedProviderFetch(keyHealthReporterFor({ platformId, providerConfigId })) })
return {
model: billedEmbeddingModel({ model: built.model, provider: credentials.provider, providerConfigId, modelId: embeddingModelId, billing }),
providerOptions: built.providerOptions,
}
}
function buildEmbeddingModel({ credentials, embeddingModelId, fetch }: {
credentials: AiProviderCredentials
embeddingModelId: string
fetch: typeof globalThis.fetch | undefined
}): { model: EmbeddingModel, providerOptions: SharedV3ProviderOptions } {
switch (credentials.provider) {
case AIProviderName.OPENAI:
return { model: createOpenAI({ apiKey: credentials.auth.apiKey, ...spreadIfDefined('fetch', fetch) }).embeddingModel(embeddingModelId), providerOptions: OPENAI_EMBEDDING_PROVIDER_OPTIONS }
case AIProviderName.GOOGLE:
return { model: createGoogleGenerativeAI({ apiKey: credentials.auth.apiKey, ...spreadIfDefined('fetch', fetch) }).textEmbeddingModel(embeddingModelId), providerOptions: {} }
case AIProviderName.AZURE: {
const { resourceName, apiVersion } = credentials.config
return {
model: createAzure({ resourceName: resourceName ?? '', apiKey: credentials.auth.apiKey, ...spreadIfDefined('apiVersion', apiVersion), ...spreadIfDefined('fetch', fetch) }).embeddingModel(embeddingModelId),
providerOptions: OPENAI_EMBEDDING_PROVIDER_OPTIONS,
}
}
case AIProviderName.ACTIVEPIECES:
case AIProviderName.OPENROUTER:
return {
model: createOpenRouter({ apiKey: credentials.auth.apiKey, ...spreadIfDefined('fetch', fetch) })
.textEmbeddingModel(embeddingModelId, EMBEDDING_REPORTS_WHAT_IT_COST),
providerOptions: OPENROUTER_EMBEDDING_PROVIDER_OPTIONS,
}
default:
throw new Error(`Provider ${credentials.provider} does not support knowledge base search`)
}
}
function managedProviderMetadataHeaders({ provider, metadata }: {
provider: AIProviderName
metadata?: ChatModelMetadata
}): Record<string, string> | undefined {
if (isNil(metadata) || provider !== AIProviderName.ACTIVEPIECES) {
return undefined
}
return {
'x-ap-platform-id': metadata.platformId,
'x-ap-conversation-id': metadata.conversationId,
...spreadIfDefined('x-ap-run-id', metadata.runId),
}
}
export const EMBEDDING_DIMENSIONS = 768
const OPENAI_EMBEDDING_PROVIDER_OPTIONS: SharedV3ProviderOptions = {
openai: { dimensions: EMBEDDING_DIMENSIONS },
}
const OPENROUTER_EMBEDDING_PROVIDER_OPTIONS: SharedV3ProviderOptions = {
openrouter: { dimensions: EMBEDDING_DIMENSIONS },
openai: { dimensions: EMBEDDING_DIMENSIONS },
}
export const aiUtils = {
createModel,
createModelForImages,
createEmbeddingModel,
toStorageEmbedding,
supportsWebSearch,
buildWebSearchTools,
buildWebSearchToolsOrThrow,
searchWeb,
}
type NativeWebSearchToolParams = {
options: WebSearchOptions
}
type UserLocation = {
type: 'approximate'
city?: string
region?: string
country?: string
timezone?: string
}
type WebSearchOptions = {
maxUses?: number
includeSources?: boolean
userLocationCity?: string
userLocationRegion?: string
userLocationCountry?: string
userLocationTimezone?: string
allowedDomains?: { domain: string }[]
blockedDomains?: { domain: string }[]
searchContextSize?: 'low' | 'medium' | 'high'
}
type FlowStepMetadata = {
projectId: string
platformId: string
flowId: string
runId: string
}
type ChatModelMetadata = {
platformId: string
conversationId: string
runId?: string
}
type WebSearchResult = {
text: string
sources: { url: string, title: string }[]
}
export type { ChatModelMetadata, FlowStepMetadata, WebSearchOptions, WebSearchResult }