n8n/dist/modules/agents/repositories/agent-execution-thread.repository.js

n8n Workflow Automation Tool

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AgentExecutionThreadRepository = void 0;
const di_1 = require("@n8n/di");
const typeorm_1 = require("@n8n/typeorm");
const agent_execution_thread_entity_1 = require("../entities/agent-execution-thread.entity");
const SESSION_NUMBER_RETRY_ATTEMPTS = 3;
let AgentExecutionThreadRepository = class AgentExecutionThreadRepository extends typeorm_1.Repository {
    constructor(dataSource) {
        super(agent_execution_thread_entity_1.AgentExecutionThread, dataSource.manager);
    }
    async findOrCreate(threadId, agentId, agentName, projectId) {
        for (let attempt = 0;; attempt++) {
            try {
                return await this.findOrCreateInSerializableTransaction(threadId, agentId, agentName, projectId);
            }
            catch (error) {
                if (attempt >= SESSION_NUMBER_RETRY_ATTEMPTS - 1 || !isRetriableWriteError(error)) {
                    throw error;
                }
            }
        }
    }
    async findOrCreateInSerializableTransaction(threadId, agentId, agentName, projectId) {
        return await this.manager.transaction('SERIALIZABLE', async (entityManager) => {
            const repository = entityManager.getRepository(agent_execution_thread_entity_1.AgentExecutionThread);
            const existing = await repository.findOneBy({ id: threadId });
            if (existing) {
                return { thread: existing, created: false };
            }
            const maxResult = await repository
                .createQueryBuilder('t')
                .select('MAX(t.sessionNumber)', 'max')
                .where('t.projectId = :projectId', { projectId })
                .getRawOne();
            const sessionNumber = (maxResult?.max ?? 0) + 1;
            const thread = repository.create({
                id: threadId,
                agentId,
                agentName,
                projectId,
                sessionNumber,
            });
            const saved = await repository.save(thread);
            return { thread: saved, created: true };
        });
    }
    async findByProjectIdPaginated(projectId, limit, cursor, agentId) {
        const where = { projectId };
        if (agentId) {
            where.agentId = agentId;
        }
        if (cursor) {
            where.updatedAt = (0, typeorm_1.LessThan)(new Date(cursor));
        }
        const threads = await this.find({
            where,
            order: { updatedAt: 'DESC' },
            take: limit + 1,
        });
        const hasMore = threads.length > limit;
        if (hasMore)
            threads.pop();
        return {
            threads,
            nextCursor: hasMore ? threads[threads.length - 1].updatedAt.toISOString() : null,
        };
    }
    async bumpUpdatedAt(threadId) {
        await this.update(threadId, { updatedAt: new Date() });
    }
    async incrementUsage(threadId, promptTokens, completionTokens, cost, duration) {
        const set = {
            totalPromptTokens: () => '"totalPromptTokens" + :promptTokens',
            totalCompletionTokens: () => '"totalCompletionTokens" + :completionTokens',
        };
        if (cost > 0) {
            set.totalCost = () => '"totalCost" + :cost';
        }
        if (duration > 0) {
            set.totalDuration = () => '"totalDuration" + :duration';
        }
        await this.createQueryBuilder()
            .update(agent_execution_thread_entity_1.AgentExecutionThread)
            .set(set)
            .where('id = :threadId', { threadId })
            .setParameters({ promptTokens, completionTokens, cost, duration })
            .execute();
    }
    async deleteByIdAndProjectId(threadId, projectId) {
        const result = await this.delete({ id: threadId, projectId });
        return (result.affected ?? 0) > 0;
    }
};
exports.AgentExecutionThreadRepository = AgentExecutionThreadRepository;
exports.AgentExecutionThreadRepository = AgentExecutionThreadRepository = __decorate([
    (0, di_1.Service)(),
    __metadata("design:paramtypes", [typeorm_1.DataSource])
], AgentExecutionThreadRepository);
function isRetriableWriteError(error) {
    if (!(error instanceof Error) || !('driverError' in error))
        return false;
    const { driverError } = error;
    if (typeof driverError !== 'object' || driverError === null || !('code' in driverError)) {
        return false;
    }
    const { code } = driverError;
    return (typeof code === 'string' &&
        (code === '40001' || code === '40P01' || code === 'SQLITE_BUSY' || code === 'SQLITE_LOCKED'));
}
//# sourceMappingURL=agent-execution-thread.repository.js.map