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 { createHash } from 'node:crypto'
import { AgentToolType, McpAuthType } from '@activepieces/core-piece-types'
import { ActivepiecesError, AIProviderName, apId, ApId, connectionTemplate, Cursor, ErrorCode, isNil, omit, Permission, PlatformId, ProjectId, sanitizeObjectForPostgresql, SeekPage, tryCatch, unique, UserId } from '@activepieces/core-utils'
import { Agent, AgentConfig, AgentFlowTool, AgentKnowledgeBaseTool, AgentListSort, AgentMoveLoss, AgentMoveLossKind, AgentMovePreview, AgentRunSource, AgentSummary, agentUtils, AgentVisibility, aiProviderUtils, CreateAgentRequest, DefaultProjectRole, Project, ProjectType, UpdateAgentRequest } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { Brackets, EntityManager, In, SelectQueryBuilder } from 'typeorm'
import { aiKeyScope } from '../../ai/ai-key-scope'
import { aiModelOptionsService, aiModelOptionsUtils } from '../../ai/ai-model-options-service'
import { AIProviderSchema } from '../../ai/ai-provider-entity'
import { aiProviderService } from '../../ai/ai-provider-service'
import { appConnectionService } from '../../app-connection/app-connection-service/app-connection-service'
import { repoFactory } from '../../core/db/repo-factory'
import { transaction } from '../../core/db/transaction'
import { publishHooksFactory } from '../../flows/flow/flow-publish-hooks'
import { flowService, getFolderIdFromRequest } from '../../flows/flow/flow.service'
import { PublishedFlowsUsingAgent, publishedFlowsUsingAgent, publishedFlowVersionsUsingAgent } from '../../flows/flow-version/flow-version.service'
import { buildPaginator } from '../../helper/pagination/build-paginator'
import { paginationHelper } from '../../helper/pagination/pagination-utils'
import { Order, OrderByConfig } from '../../helper/pagination/paginator'
import { knowledgeBaseService } from '../../knowledge-base/knowledge-base.service'
import { resolvePermissionChecker } from '../../mcp/mcp-permissions'
import { platformConfigurationService } from '../../platform/platform-configuration.service'
import { projectService } from '../../project/project-service'
import { userService } from '../../user/user-service'
import { projectMemberService } from '../projects/project-members/project-member.service'
import { AgentConversationEntity } from './agent-conversation-entity'
import { AgentEntity, AgentWithRelations } from './agent-entity'
import { agentHelpers } from './agent-helpers'
import { agentModelTier } from './agent-model-tier'
const DEFAULT_PAGE_SIZE = 20
const MAX_NAMED_FLOWS_IN_USE = 3
export const agentRepo = repoFactory(AgentEntity)
export const agentAudit = { describePublished }
export const agentRedaction = { withoutToolSecrets }
const AGENT_MOVED_AWAY = 'That agent has just been moved somewhere else. Reload the page and try again.'
export const agentService = (log: FastifyBaseLogger) => ({
async create({ platformId, projectId, ownerId, request }: CreateParams): Promise<Agent> {
const visibility = request.visibility ?? AgentVisibility.PROJECT
const draft = await withPinnedKey({ draft: await withDefaultModel({ draft: await withTierOrModel({ draft: request.draft, platformId, projectId, log }), platformId, projectId, log }), platformId, projectId, log })
return agentRepo().save({
id: apId(),
projectId,
ownerId,
externalId: apId(),
displayName: request.displayName,
description: request.description ?? null,
folderId: await getFolderIdFromRequest({ projectId, folderId: request.folderId ?? undefined, folderName: undefined, log }),
icon: request.icon,
color: request.color,
visibility,
sharedWithUserIds: await resolveShare({ visibility, requested: request.sharedWithUserIds, stored: [], projectId, log }),
draft: sanitizeObjectForPostgresql(draft),
published: null,
})
},
async list({ platformId, userId, projectId, search, sort, cursor, limit, connectionExternalIds }: ListParams): Promise<SeekPage<AgentSummary>> {
const readableProjects = await resolveReadableProjects({ platformId, userId, projectId, log })
const readableProjectIds = readableProjects.map((project) => project.id)
if (readableProjectIds.length === 0) {
return paginationHelper.createPage([], null)
}
const projectById = new Map(readableProjects.map((project) => [project.id, project]))
const { nextCursor, previousCursor } = paginationHelper.decodeCursor(cursor)
const paginator = buildPaginator({
entity: AgentEntity,
query: {
limit: limit ?? DEFAULT_PAGE_SIZE,
orderBy: orderByForSort(sort),
afterCursor: nextCursor,
beforeCursor: previousCursor,
},
})
const query = visibleAgents({ userId, isProjectAdmin: false }).andWhere({ projectId: In(readableProjectIds) })
const needle = search?.trim().toLowerCase()
if (!isNil(needle) && needle.length > 0) {
query.andWhere(new Brackets((qb) => {
qb.where('LOWER(agent."displayName") LIKE :needle', { needle: `%${needle}%` })
.orWhere('LOWER(COALESCE(agent."description", \'\')) LIKE :needle', { needle: `%${needle}%` })
}))
}
if (!isNil(connectionExternalIds) && connectionExternalIds.length > 0) {
const connectionAuths = connectionExternalIds.flatMap((externalId) => [externalId, connectionTemplate.wrapExternalId(externalId) ?? externalId])
query.andWhere(`EXISTS (
SELECT 1 FROM jsonb_array_elements((agent."draft"->'tools') || COALESCE(agent."published"->'tools', '[]'::jsonb)) AS tool
WHERE tool->'pieceMetadata'->'predefinedInput'->>'auth' = ANY(:connectionAuths)
)`, { connectionAuths })
}
const { data, cursor: newCursor } = await paginator.paginate(query)
return paginationHelper.createPage(data.map((agent) => toSummary(agent, projectById.get(agent.projectId))), newCursor)
},
async getOneOrThrow({ id, projectId, userId }: GetParams): Promise<Agent> {
const isProjectAdmin = await isProjectAdministrator({ projectId, userId, log })
const agent = await visibleAgents({ userId, isProjectAdmin }).andWhere({ id, projectId }).getOne()
if (isNil(agent)) {
throw agentNotFound(id)
}
return agent
},
async getOneOrThrowByPlatform({ id, platformId, userId }: GetByPlatformParams): Promise<Agent> {
const readableProjectIds = (await resolveReadableProjects({ platformId, userId, log })).map((project) => project.id)
if (readableProjectIds.length === 0) {
throw agentNotFound(id)
}
const agent = await visibleAgents({ userId, isProjectAdmin: false })
.andWhere({ id, projectId: In(readableProjectIds) })
.getOne()
if (isNil(agent)) {
throw agentNotFound(id)
}
return this.getOneOrThrow({ id, projectId: agent.projectId, userId })
},
async update({ id, projectId, platformId, userId, request, goLive = false }: UpdateParams): Promise<Agent> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
await assertMayChangeWhoCanSee({ agent, request, projectId, userId, log })
const requestedDraft = isNil(request.draft) ? null : sanitizeObjectForPostgresql(await withPinnedKey({ draft: await withTierOrModel({ draft: request.draft, platformId, projectId, log }), platformId, projectId, log }))
await getFolderIdFromRequest({ projectId, folderId: request.folderId ?? undefined, folderName: undefined, log })
await transaction(async (entityManager) => {
const locked = await lockedAgentInProjectOrThrow({ entityManager, id, projectId })
const draft = requestedDraft ?? locked.draft
const visibility = request.visibility ?? locked.visibility
const sharedWithUserIds = await resolveShare({ visibility, requested: request.sharedWithUserIds, stored: locked.sharedWithUserIds, projectId, log })
const goingLive = goLive && agentUtils.isPublishable(draft)
if (goingLive) {
assertDraftIsCoherent(draft)
await assertMayPublishWhatFlowsAlreadyRun({ agent: locked, projectId, platformId, userId, log })
}
const published = goingLive ? draft : locked.published
await entityManager.getRepository(AgentEntity).save({ id, ...omit(request, ['goLive', 'draft', 'visibility', 'sharedWithUserIds']), draft, published, visibility, sharedWithUserIds })
})
return this.getOneOrThrow({ id, projectId, userId })
},
async publish({ id, projectId, platformId, userId }: GetParams & { platformId: PlatformId }): Promise<Agent> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
if (!agentUtils.isPublishable(agent.draft)) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'An agent needs instructions before it can be published' },
})
}
assertDraftIsCoherent(agent.draft)
await assertMayPublishWhatFlowsAlreadyRun({ agent, projectId, platformId, userId, log })
const needsApproval = await publishingNeedsApprovalHere({ projectId, platformId, userId, log })
const blocking = publishedFlowVersionsUsingAgent({ projectId, agentExternalId: agent.externalId, alias: 'blocking_version' })
const publishQuery = agentRepo()
.createQueryBuilder()
.update()
.set({ published: () => '"draft"' })
.where('"id" = :id AND "projectId" = :projectId', { id, projectId })
.andWhere('"draft" = CAST(:reviewedDraft AS jsonb)', { reviewedDraft: JSON.stringify(agent.draft) })
.andWhere(visibleToUser({ userId, prefix: '', isProjectAdmin: await isProjectAdministrator({ projectId, userId, log }) }))
if (needsApproval) {
publishQuery
.andWhere(`NOT EXISTS (${blocking.getQuery()})`)
.setParameters(blocking.getParameters())
}
const published = await publishQuery
.returning('id')
.execute()
const publishedRows: unknown[] = published.raw ?? []
if (publishedRows.length === 0) {
if (needsApproval && (await agentService(log).publishedFlowsUsing({ agent, projectId, userId })).total > 0) {
throw refuseBecauseAnApprovedFlowRunsIt({ agent })
}
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'The agent changed while it was being published, review it and publish again' },
})
}
return this.getOneOrThrow({ id, projectId, userId })
},
async unpublish({ id, projectId, userId }: GetParams): Promise<Agent> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
const blocking = publishedFlowVersionsUsingAgent({ projectId, agentExternalId: agent.externalId, alias: 'blocking_version' })
const unpublished = await agentRepo()
.createQueryBuilder()
.update()
.set({ published: null })
.where('"id" = :id AND "projectId" = :projectId', { id, projectId })
.andWhere(visibleToUser({ userId, prefix: '', isProjectAdmin: await isProjectAdministrator({ projectId, userId, log }) }))
.andWhere(`NOT EXISTS (${blocking.getQuery()})`)
.setParameters(blocking.getParameters())
.returning('id')
.execute()
const unpublishedRows: unknown[] = unpublished.raw ?? []
if (unpublishedRows.length === 0) {
throw refuseBecauseFlowsUseIt({ agent, flowsInUse: await this.publishedFlowsUsing({ agent, projectId, userId }) })
}
return this.getOneOrThrow({ id, projectId, userId })
},
async getProjectVisibleByExternalId({ projectId, externalId }: { projectId: ProjectId, externalId: string }): Promise<Agent | null> {
return agentRepo().findOneBy({ projectId, externalId, visibility: AgentVisibility.PROJECT })
},
async editDraftTools({ id, projectId, userId, edit }: EditDraftToolsParams): Promise<Agent | null> {
return transaction(async (entityManager) => {
const repo = entityManager.getRepository(AgentEntity)
const agent = await repo.createQueryBuilder('agent')
.setLock('pessimistic_write')
.where('agent.id = :id AND agent."projectId" = :projectId', { id, projectId })
.getOne()
if (isNil(agent)) {
return null
}
const tools = edit(agent.draft.tools)
if (isNil(tools)) {
return null
}
const draft = AgentConfig.safeParse({ ...agent.draft, tools })
if (!draft.success) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: `That tool change leaves the agent outside what an agent may hold: ${draft.error.issues.map((issue) => issue.message).join(', ')}` },
})
}
await repo.save({ id, draft: sanitizeObjectForPostgresql(draft.data) })
return this.getOneOrThrow({ id, projectId, userId })
})
},
async publishedFlowsUsing({ agent, projectId, userId, nameLimit = MAX_NAMED_FLOWS_IN_USE }: { agent: Agent, projectId: ProjectId, userId: UserId, nameLimit?: number }): Promise<PublishedFlowsUsingAgent> {
const checker = await resolvePermissionChecker({ userId, projectId, log })
const mayReadFlows = isNil(checker.check(Permission.READ_FLOW, '__name_flows_using_agent'))
return publishedFlowsUsingAgent({ projectId, agentExternalId: agent.externalId, nameLimit: mayReadFlows ? nameLimit : 0 })
},
async movePreview({ id, projectId, userId, targetProjectId, platformId }: MoveParams & { id: string }): Promise<AgentMovePreview> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
await assertMayDestroy({ agent, projectId, userId, log })
const target = await readableProjectOrThrow({ platformId, userId, targetProjectId, log })
const [flowsInUse, mayCreateAgentsThere] = await Promise.all([
this.publishedFlowsUsing({ agent, projectId, userId, nameLimit: AGENT_USAGE_LIST_LIMIT }),
mayWriteAgentsIn({ projectId: target.id, userId, log }),
])
if (!mayCreateAgentsThere) {
return { blockedByPublishedFlows: flowsInUse, mayCreateAgentsThere, toolsThatStopWorking: [], membersLosingAccess: 0 }
}
const [toolsThatStopWorking, sharedWithUserIds] = await Promise.all([
toolsBrokenBy({ agent, targetProjectId: target.id, log }),
resolveShare({ visibility: agent.visibility, requested: undefined, stored: agent.sharedWithUserIds, projectId: target.id, log }),
])
return {
blockedByPublishedFlows: flowsInUse,
mayCreateAgentsThere,
toolsThatStopWorking,
membersLosingAccess: agent.sharedWithUserIds.length - sharedWithUserIds.length,
}
},
async move({ id, projectId, userId, targetProjectId, platformId }: MoveParams & { id: string }): Promise<Agent> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
if (agent.projectId === targetProjectId) {
return agent
}
await assertMayRemoveFromProject({ agent, projectId, userId, log })
const target = await readableProjectOrThrow({ platformId, userId, targetProjectId, log })
await assertMayWriteAgentsIn({ projectId: target.id, userId, log })
await transaction(async (entityManager) => {
const repo = entityManager.getRepository(AgentEntity)
const locked = await lockedAgentInProjectOrThrow({ entityManager, id, projectId })
const [draft, published] = await Promise.all([
withKeyFor({ config: locked.draft, platformId, projectId: target.id, entityManager, log }),
isNil(locked.published) ? null : withKeyFor({ config: locked.published, platformId, projectId: target.id, entityManager, log }),
])
const sharedWithUserIds = await resolveShare({ visibility: locked.visibility, requested: undefined, stored: locked.sharedWithUserIds, projectId: target.id, log })
const clash = await repo.findOneBy({ projectId: target.id, externalId: agent.externalId })
if (!isNil(clash)) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: `"${target.displayName}" already holds an agent with the same external id, so this one cannot move there.` },
})
}
const blocking = publishedFlowVersionsUsingAgent({ projectId, agentExternalId: agent.externalId, alias: 'blocking_version' })
const moved = await repo.createQueryBuilder()
.update()
.set({ projectId: target.id, sharedWithUserIds, folderId: null })
.where('"id" = :id AND "projectId" = :projectId', { id, projectId })
.andWhere(`NOT EXISTS (${blocking.getQuery()})`)
.setParameters(blocking.getParameters())
.returning('id')
.execute()
const movedRows: unknown[] = moved.raw ?? []
if (movedRows.length === 0) {
throw refuseBecauseFlowsUseIt({ agent, flowsInUse: await agentService(log).publishedFlowsUsing({ agent, projectId, userId }) })
}
await repo.save({ id, draft, published })
await entityManager.getRepository(AgentConversationEntity).update(
{ agentId: id, source: AgentRunSource.AGENT },
{ projectId: target.id },
)
})
return this.getOneOrThrow({ id, projectId: target.id, userId })
},
async delete({ id, projectId, userId }: GetParams): Promise<Agent> {
const agent = await this.getOneOrThrow({ id, projectId, userId })
await assertMayRemoveFromProject({ agent, projectId, userId, log })
const blocking = publishedFlowVersionsUsingAgent({ projectId, agentExternalId: agent.externalId, alias: 'blocking_version' })
const deleted = await transaction(async (entityManager) => {
await lockedAgentInProjectOrThrow({ entityManager, id, projectId })
return entityManager.getRepository(AgentEntity)
.createQueryBuilder()
.delete()
.where('"id" = :id AND "projectId" = :projectId', { id, projectId })
.andWhere(`NOT EXISTS (${blocking.getQuery()})`)
.setParameters(blocking.getParameters())
.returning('id')
.execute()
})
const deletedRows: unknown[] = deleted.raw ?? []
if (deletedRows.length === 0) {
throw refuseBecauseFlowsUseIt({ agent, flowsInUse: await this.publishedFlowsUsing({ agent, projectId, userId }) })
}
return agent
},
})
function assertDraftIsCoherent(draft: AgentConfig): void {
if (!isNil(draft.providerConfigId) && isNil(draft.provider)) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'This agent pins an AI provider key without naming its provider, so a run would resolve a different one. Pick the provider that key belongs to.' },
})
}
}
async function publishingNeedsApprovalHere({ projectId, platformId, userId, log }: {
projectId: ProjectId
platformId: PlatformId
userId: UserId
log: FastifyBaseLogger
}): Promise<boolean> {
const route = await publishHooksFactory.get(log).routePublish({ projectId, platformId, userId })
return route !== 'PUBLISH_NOW'
}
function refuseBecauseAnApprovedFlowRunsIt({ agent }: { agent: Agent }): ActivepiecesError {
return new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: `A published flow in this project runs "${agent.displayName}", and publishing a flow here needs approval, so its tools and instructions cannot be changed under an approved flow. Ask someone who can publish sensitive flows to publish this agent.` },
})
}
async function assertMayPublishWhatFlowsAlreadyRun({ agent, projectId, platformId, userId, log }: {
agent: Agent
projectId: ProjectId
platformId: PlatformId
userId: UserId
log: FastifyBaseLogger
}): Promise<void> {
if (!await publishingNeedsApprovalHere({ projectId, platformId, userId, log })) {
return
}
const flowsInUse = await agentService(log).publishedFlowsUsing({ agent, projectId, userId })
if (flowsInUse.total === 0) {
return
}
throw refuseBecauseAnApprovedFlowRunsIt({ agent })
}
function refuseBecauseFlowsUseIt({ agent, flowsInUse }: {
agent: Agent
flowsInUse: PublishedFlowsUsingAgent
}): ActivepiecesError {
if (flowsInUse.total === 0) {
return agentNotFound(agent.id)
}
return new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: describeFlowsInUse(flowsInUse) },
})
}
function describeFlowsInUse({ total, flows }: PublishedFlowsUsingAgent): string {
const counted = total === 1 ? '1 published flow' : `${total} published flows`
if (flows.length === 0) {
return `This agent is running in ${counted}. Remove it from them first.`
}
const listed = flows.map((flow) => flow.displayName).join(', ')
const tail = total > flows.length ? `, and ${total - flows.length} more` : ''
return `This agent is running in ${counted} (${listed}${tail}). Remove it from them first.`
}
function orderByForSort(sort?: AgentListSort): OrderByConfig[] {
switch (sort) {
case AgentListSort.NAME:
return [{ field: 'displayName', order: Order.ASC }]
case AgentListSort.CREATED:
return [{ field: 'created', order: Order.DESC }]
case AgentListSort.UPDATED:
default:
return [{ field: 'updated', order: Order.DESC }]
}
}
function visibleAgents({ userId, isProjectAdmin }: { userId: UserId, isProjectAdmin: boolean }): SelectQueryBuilder<AgentWithRelations> {
return agentRepo()
.createQueryBuilder('agent')
.where(visibleToUser({ userId, prefix: 'agent.', isProjectAdmin }))
}
function visibleToUser({ userId, prefix, isProjectAdmin }: VisibilityParams): Brackets {
return new Brackets((qb) => {
qb.where(`${prefix}"visibility" = :projectVisibility`, { projectVisibility: AgentVisibility.PROJECT })
.orWhere(`${prefix}"ownerId" = :userId`, { userId })
.orWhere(`:userId = ANY(${prefix}"sharedWithUserIds")`, { userId })
if (isProjectAdmin) {
qb.orWhere('1 = 1')
}
})
}
async function isProjectAdministrator({ projectId, userId, log }: { projectId: ProjectId, userId: UserId, log: FastifyBaseLogger }): Promise<boolean> {
const role = await projectMemberService(log).getRole({ projectId, userId })
return role?.name === DefaultProjectRole.ADMIN
}
async function withTierOrModel({ draft, platformId, projectId, log }: { draft: AgentConfig, platformId: PlatformId, projectId: ProjectId, log: FastifyBaseLogger }): Promise<AgentConfig> {
if (isNil(draft.modelTierId)) {
return draft
}
await agentModelTier(log).assertUsable({ platformId, tierId: draft.modelTierId, scope: { type: 'project', projectId } })
return { ...draft, provider: null, providerConfigId: null, modelName: null }
}
async function withDefaultModel({ draft, platformId, projectId, log }: {
draft: AgentConfig
platformId: PlatformId
projectId: ProjectId
log: FastifyBaseLogger
}): Promise<AgentConfig> {
if (!isNil(draft.modelName) || !isNil(draft.modelTierId)) {
return draft
}
const platformDefault = (await platformConfigurationService(log).getOrCreateForPlatform({ platformId })).defaultChatModel
if (!isNil(platformDefault)) {
const { data: options } = await tryCatch(() => aiModelOptionsService(log).list({ platformId, projectId, surface: 'agent' }))
const usable = isNil(options) ? null : aiModelOptionsUtils.usableChoice({ choice: platformDefault, tiers: options.tiers, credits: options.credits ?? null, keys: options.keys, movedTiers: options.movedTiers })
if (!isNil(usable)) {
return usable.type === 'tier'
? { ...draft, modelTierId: usable.tierId, provider: null, providerConfigId: null, modelName: null }
: { ...draft, provider: usable.provider, providerConfigId: usable.providerConfigId, modelName: usable.modelId, modelTierId: null }
}
}
const chatKey = await aiProviderService(log).getChatKey({ platformId, scope: { type: 'project', projectId } })
if (isNil(chatKey)) {
return draft
}
const { provider, id: providerConfigId } = chatKey
const modelName = provider === AIProviderName.ACTIVEPIECES
? agentHelpers.resolveTier({ tierId: null, surface: 'flow' }).id
: firstChatModelId({ key: chatKey }) ?? agentHelpers.defaultModelIdForProvider({ provider, surface: 'flow', config: chatKey.config, modelScope: chatKey.modelScope, modelIds: chatKey.modelIds })
if (isNil(modelName)) {
return { ...draft, provider, providerConfigId }
}
return { ...draft, provider, providerConfigId, modelName }
}
function firstChatModelId({ key }: { key: AIProviderSchema }): string | undefined {
if (!isNil(aiKeyScope.manualModelIdsOf({ config: key.config }))) {
return undefined
}
return aiProviderUtils.runnableChatModelIds({ provider: key.provider })
.find((modelId) => aiKeyScope.scopeAllows({ modelScope: key.modelScope, modelIds: key.modelIds, modelId }))
}
async function withPinnedKey({ draft, platformId, projectId, log }: {
draft: AgentConfig
platformId: PlatformId
projectId: ProjectId
log: FastifyBaseLogger
}): Promise<AgentConfig> {
if (isNil(draft.provider) || !isNil(draft.providerConfigId) || !isNil(draft.modelTierId)) {
return draft
}
const configId = await aiProviderService(log).findRunKeyId({ platformId, provider: draft.provider, scope: { type: 'project', projectId } })
return isNil(configId) ? draft : { ...draft, providerConfigId: configId }
}
async function withKeyFor({ config, platformId, projectId, entityManager, log }: {
config: AgentConfig
platformId: PlatformId
projectId: ProjectId
entityManager: EntityManager
log: FastifyBaseLogger
}): Promise<AgentConfig> {
if (isNil(config.provider) || isNil(config.providerConfigId)) {
return config
}
const providerConfigId = await aiProviderService(log).findRunKeyId({ platformId, provider: config.provider, scope: { type: 'project', projectId }, preferredConfigId: config.providerConfigId, entityManager })
return { ...config, providerConfigId }
}
async function resolveShare({ visibility, requested, stored, projectId, log }: ResolveShareParams): Promise<UserId[]> {
if (visibility === AgentVisibility.PROJECT) {
return []
}
const uniqueUserIds = [...new Set(requested ?? stored)]
if (uniqueUserIds.length === 0) {
return []
}
const withAccess = await listUsersWithProjectAccess({ projectId, log })
if (isNil(requested)) {
return uniqueUserIds.filter((userId) => withAccess.includes(userId))
}
const strangers = uniqueUserIds.filter((userId) => !withAccess.includes(userId))
if (strangers.length > 0) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'An agent can only be shared with people who already have access to its project' },
})
}
return uniqueUserIds
}
async function assertMayChangeWhoCanSee({ agent, request, projectId, userId, log }: AssertShareParams): Promise<void> {
const changesWhoCanSee = !isNil(request.visibility) || !isNil(request.sharedWithUserIds)
if (!changesWhoCanSee || agent.ownerId === userId) {
return
}
if (await isProjectAdministrator({ projectId, userId, log })) {
return
}
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: { message: 'Only the person who created an agent, or a project admin, can change who sees it' },
})
}
export async function assertAgentsResolveInProject({ projectId, agentExternalIds, entityManager }: { projectId: ProjectId, agentExternalIds: string[], entityManager: EntityManager }): Promise<void> {
if (agentExternalIds.length === 0) {
return
}
const resolved = await entityManager.getRepository(AgentEntity)
.createQueryBuilder('agent')
.select(['agent.externalId', 'agent.displayName', 'agent.visibility', 'agent.published'])
.setLock('pessimistic_read')
.where('agent."projectId" = :projectId', { projectId })
.andWhere('agent."externalId" IN (:...agentExternalIds)', { agentExternalIds })
.getMany()
const missing = agentExternalIds.filter((externalId) => !resolved.some((agent) => agent.externalId === externalId))
if (missing.length > 0) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'This flow runs an agent that is not in this project any more. Point the step at an agent here, then publish.' },
})
}
const unrunnable = resolved.find((agent) => agent.visibility !== AgentVisibility.PROJECT || isNil(agent.published))
if (!isNil(unrunnable)) {
const reason = unrunnable.visibility === AgentVisibility.PROJECT
? `"${unrunnable.displayName}" has never been published, and a flow runs the published version`
: `"${unrunnable.displayName}" is only visible to some people, and a flow runs unattended, so it can only run an agent the whole project can see`
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: `${reason}. Fix that on the agent, then publish this flow.` },
})
}
}
async function readableProjectOrThrow({ platformId, userId, targetProjectId, log }: { platformId: PlatformId, userId: UserId, targetProjectId: ProjectId, log: FastifyBaseLogger }): Promise<Project> {
const [target] = await resolveReadableProjects({ platformId, userId, projectId: targetProjectId, log })
if (isNil(target)) {
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: { message: 'That project is not one you can move an agent into' },
})
}
return target
}
async function assertMayWriteAgentsIn({ projectId, userId, log }: { projectId: ProjectId, userId: UserId, log: FastifyBaseLogger }): Promise<void> {
if (await mayWriteAgentsIn({ projectId, userId, log })) {
return
}
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: { message: 'Your role in that project cannot create or change agents there' },
})
}
async function assertMayRemoveFromProject({ agent, projectId, userId, log }: AssertDestroyParams): Promise<void> {
await assertMayDestroy({ agent, projectId, userId, log })
const flowsInUse = await agentService(log).publishedFlowsUsing({ agent, projectId, userId })
if (flowsInUse.total > 0) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: describeFlowsInUse(flowsInUse) },
})
}
}
async function lockedAgentInProjectOrThrow({ entityManager, id, projectId }: { entityManager: EntityManager, id: string, projectId: ProjectId }): Promise<Agent> {
const locked = await entityManager.getRepository(AgentEntity)
.createQueryBuilder('agent')
.setLock('pessimistic_write')
.where('agent.id = :id', { id })
.getOne()
if (isNil(locked) || locked.projectId !== projectId) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: AGENT_MOVED_AWAY },
})
}
return locked
}
async function mayWriteAgentsIn({ projectId, userId, log }: { projectId: ProjectId, userId: UserId, log: FastifyBaseLogger }): Promise<boolean> {
const checker = await resolvePermissionChecker({ userId, projectId, log })
return isNil(checker.check(Permission.WRITE_AGENT, '__move_agent_into_project'))
}
async function toolsBrokenBy({ agent, targetProjectId, log }: { agent: Agent, targetProjectId: ProjectId, log: FastifyBaseLogger }): Promise<AgentMoveLoss[]> {
const pinned = agent.draft.tools.flatMap((tool) => {
if (tool.type !== AgentToolType.PIECE) {
return []
}
const externalId = connectionTemplate.unwrapExternalId(tool.pieceMetadata.predefinedInput?.auth)
return isNil(externalId) ? [] : [{ pieceName: tool.pieceMetadata.pieceName, externalId }]
})
const flowTools = agent.draft.tools.filter((tool): tool is AgentFlowTool => tool.type === AgentToolType.FLOW)
const knowledgeTools = agent.draft.tools.filter((tool): tool is AgentKnowledgeBaseTool => tool.type === AgentToolType.KNOWLEDGE_BASE)
const [connectionsThere, flowsThere, knowledgeThere] = await Promise.all([
pinned.length === 0 ? Promise.resolve([]) : appConnectionService(log).getManyConnectionStates({ projectId: targetProjectId }),
flowTools.length === 0 ? Promise.resolve({ data: [] }) : flowService(log).list({
projectIds: [targetProjectId],
externalIds: unique(flowTools.map((tool) => tool.externalFlowId)),
cursorRequest: null,
includeTriggerSource: false,
}),
knowledgeTools.length === 0 ? Promise.resolve([]) : knowledgeBaseService(log).getFilesByIds({
projectId: targetProjectId,
ids: unique(knowledgeTools.map((tool) => tool.sourceId)),
}),
])
const connectionIdsThere = new Set(connectionsThere.map((connection) => connection.externalId))
const flowIdsThere = new Set(flowsThere.data.map((flow) => flow.externalId))
const knowledgeIdsThere = new Set(knowledgeThere.map((file) => file.id))
return [
...unique(pinned.filter((pin) => !connectionIdsThere.has(pin.externalId)).map((pin) => pin.pieceName))
.map((label) => ({ kind: AgentMoveLossKind.CONNECTION, label })),
...unique(flowTools.filter((tool) => !flowIdsThere.has(tool.externalFlowId)).map((tool) => tool.flowDisplayName ?? tool.toolName))
.map((label) => ({ kind: AgentMoveLossKind.FLOW, label })),
...unique(knowledgeTools.filter((tool) => !knowledgeIdsThere.has(tool.sourceId)).map((tool) => tool.sourceName))
.map((label) => ({ kind: AgentMoveLossKind.KNOWLEDGE, label })),
]
}
async function assertMayDestroy({ agent, projectId, userId, log }: AssertDestroyParams): Promise<void> {
if (agent.ownerId === userId || await isProjectAdministrator({ projectId, userId, log })) {
return
}
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: { message: 'Only the person who created an agent, or a project admin, can delete it and the conversations held with it' },
})
}
async function listUsersWithProjectAccess({ projectId, log }: { projectId: ProjectId, log: FastifyBaseLogger }): Promise<UserId[]> {
const [members, project] = await Promise.all([
projectMemberService(log).listProjectMemberUserIds({ projectId }),
projectService(log).getOneOrThrow(projectId),
])
return [...new Set([...members, project.ownerId])]
}
async function resolveReadableProjects({ platformId, userId, projectId, log }: ResolveProjectsParams): Promise<Project[]> {
const users = userService(log)
const user = await users.getOneOrFail({ id: userId })
const isPrivileged = users.isUserPrivileged(user)
const projects = await agentHelpers.getUserProjects({ platformId, userId, log })
const permittedProjectIds = isPrivileged
? []
: await projectMemberService(log).listProjectIdsWithPermission({ userId, platformId, permission: Permission.READ_AGENT })
return projects
.filter((project) => isPrivileged || project.ownerId === userId || permittedProjectIds.includes(project.id))
.filter((project) => isNil(projectId) || project.id === projectId)
}
function toSummary(agent: Agent, project?: Project): AgentSummary {
return {
...omit(agent, ['draft', 'published']),
isPublished: !isNil(agent.published),
projectDisplayName: project?.displayName ?? '',
projectIsPrivate: project?.type === ProjectType.PERSONAL,
toolCount: agent.draft.tools.length,
toolPieceNames: agent.draft.tools.flatMap((tool) => tool.type === AgentToolType.PIECE ? [tool.pieceMetadata.pieceName] : []),
toolTypes: agent.draft.tools.map((tool) => tool.type),
}
}
function withoutToolSecrets(agent: Agent): Agent {
return {
...agent,
draft: redactConfig(agent.draft),
published: isNil(agent.published) ? agent.published : redactConfig(agent.published),
}
}
function redactConfig(config: AgentConfig): AgentConfig {
return {
...config,
tools: config.tools.map((tool) => tool.type !== AgentToolType.MCP || tool.auth.type === McpAuthType.NONE
? tool
: { ...tool, auth: { type: tool.auth.type } as typeof tool.auth }),
}
}
function describePublished({ published }: { published: AgentConfig }): { publishedDigest: string, publishedToolNames: string[] } {
return {
publishedDigest: createHash('sha256').update(JSON.stringify(published)).digest('hex').slice(0, 16),
publishedToolNames: published.tools.map((tool) => tool.toolName),
}
}
function agentNotFound(id: ApId): ActivepiecesError {
return new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: { entityId: id, entityType: 'agent' },
})
}
type CreateParams = {
platformId: PlatformId
projectId: ProjectId
ownerId: UserId
request: CreateAgentRequest
}
type ListParams = {
platformId: PlatformId
userId: UserId
projectId?: ProjectId
search?: string
sort?: AgentListSort
cursor?: Cursor
limit?: number
connectionExternalIds?: string[]
}
type MoveParams = {
projectId: ProjectId
userId: UserId
targetProjectId: ProjectId
platformId: PlatformId
}
type EditDraftToolsParams = GetParams & {
edit: (tools: AgentConfig['tools']) => AgentConfig['tools'] | null
}
type GetParams = {
id: ApId
projectId: ProjectId
userId: UserId
}
type GetByPlatformParams = {
id: string
platformId: PlatformId
userId: UserId
}
type UpdateParams = GetParams & {
platformId: PlatformId
request: UpdateAgentRequest
goLive?: boolean
}
type ResolveProjectsParams = {
platformId: PlatformId
userId: UserId
projectId?: ProjectId
log: FastifyBaseLogger
}
type ResolveShareParams = {
visibility: AgentVisibility
requested?: UserId[]
stored: UserId[]
projectId: ProjectId
log: FastifyBaseLogger
}
type VisibilityParams = {
userId: UserId
prefix: 'agent.' | ''
isProjectAdmin: boolean
}
type AssertDestroyParams = {
agent: Agent
projectId: ProjectId
userId: UserId
log: FastifyBaseLogger
}
type AssertShareParams = {
agent: Agent
request: UpdateAgentRequest
projectId: ProjectId
userId: UserId
log: FastifyBaseLogger
}
export const AGENT_USAGE_LIST_LIMIT = 100