Skip to content

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

16.3 KB
Raw Blame
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 }