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

39.2 KB
Raw Blame
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