n8n 2.22.3 → 2.23.0

package/dist/modules/agents/integrations/n8n-memory.js

@@ -9,16 +9,24 @@ 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.N8nMemory = void 0;
+exports.N8nMemoryImpl = exports.N8nMemory = void 0;
 const agents_1 = require("@n8n/agents");
 const di_1 = require("@n8n/di");
 const typeorm_1 = require("@n8n/typeorm");
-const n8n_workflow_1 = require("n8n-workflow");
+const response_helper_1 = require("../../../response-helper");
+const agent_memory_entry_cursor_entity_1 = require("../entities/agent-memory-entry-cursor.entity");
+const agent_memory_entry_entity_1 = require("../entities/agent-memory-entry.entity");
+const agent_memory_entry_lock_entity_1 = require("../entities/agent-memory-entry-lock.entity");
+const agent_memory_entry_source_entity_1 = require("../entities/agent-memory-entry-source.entity");
 const agent_observation_cursor_entity_1 = require("../entities/agent-observation-cursor.entity");
 const agent_observation_lock_entity_1 = require("../entities/agent-observation-lock.entity");
 const agent_observation_entity_1 = require("../entities/agent-observation.entity");
 const agent_thread_entity_1 = require("../entities/agent-thread.entity");
 const agent_message_repository_1 = require("../repositories/agent-message.repository");
+const agent_memory_entry_cursor_repository_1 = require("../repositories/agent-memory-entry-cursor.repository");
+const agent_memory_entry_lock_repository_1 = require("../repositories/agent-memory-entry-lock.repository");
+const agent_memory_entry_source_repository_1 = require("../repositories/agent-memory-entry-source.repository");
+const agent_memory_entry_repository_1 = require("../repositories/agent-memory-entry.repository");
 const agent_observation_cursor_repository_1 = require("../repositories/agent-observation-cursor.repository");
 const agent_observation_lock_repository_1 = require("../repositories/agent-observation-lock.repository");
 const agent_observation_repository_1 = require("../repositories/agent-observation.repository");
@@ -26,13 +34,61 @@ const agent_resource_repository_1 = require("../repositories/agent-resource.repo
 const agent_thread_repository_1 = require("../repositories/agent-thread.repository");
 const estimateObservationTokens = (text) => Math.ceil(text.length / 4);
 let N8nMemory = class N8nMemory {
-    constructor(threadRepository, messageRepository, resourceRepository, observationRepository, observationCursorRepository, observationLockRepository) {
+    constructor(threadRepository, messageRepository, resourceRepository, observationRepository, observationCursorRepository, observationLockRepository, memoryEntryRepository, memoryEntryLockRepository, memoryEntrySourceRepository, memoryEntryCursorRepository) {
         this.threadRepository = threadRepository;
         this.messageRepository = messageRepository;
         this.resourceRepository = resourceRepository;
         this.observationRepository = observationRepository;
         this.observationCursorRepository = observationCursorRepository;
         this.observationLockRepository = observationLockRepository;
+        this.memoryEntryRepository = memoryEntryRepository;
+        this.memoryEntryLockRepository = memoryEntryLockRepository;
+        this.memoryEntrySourceRepository = memoryEntrySourceRepository;
+        this.memoryEntryCursorRepository = memoryEntryCursorRepository;
+    }
+    getImplementation(agentId) {
+        return new N8nMemoryImpl(agentId, this.threadRepository, this.messageRepository, this.resourceRepository, this.observationRepository, this.observationCursorRepository, this.observationLockRepository, this.memoryEntryRepository, this.memoryEntryLockRepository, this.memoryEntrySourceRepository, this.memoryEntryCursorRepository);
+    }
+};
+exports.N8nMemory = N8nMemory;
+exports.N8nMemory = N8nMemory = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [agent_thread_repository_1.AgentThreadRepository,
+        agent_message_repository_1.AgentMessageRepository,
+        agent_resource_repository_1.AgentResourceRepository,
+        agent_observation_repository_1.AgentObservationRepository,
+        agent_observation_cursor_repository_1.AgentObservationCursorRepository,
+        agent_observation_lock_repository_1.AgentObservationLockRepository,
+        agent_memory_entry_repository_1.AgentMemoryEntryRepository,
+        agent_memory_entry_lock_repository_1.AgentMemoryEntryLockRepository,
+        agent_memory_entry_source_repository_1.AgentMemoryEntrySourceRepository,
+        agent_memory_entry_cursor_repository_1.AgentMemoryEntryCursorRepository])
+], N8nMemory);
+class N8nMemoryImpl {
+    constructor(agentId, threadRepository, messageRepository, resourceRepository, observationRepository, observationCursorRepository, observationLockRepository, memoryEntryRepository, memoryEntryLockRepository, memoryEntrySourceRepository, memoryEntryCursorRepository) {
+        this.agentId = agentId;
+        this.threadRepository = threadRepository;
+        this.messageRepository = messageRepository;
+        this.resourceRepository = resourceRepository;
+        this.observationRepository = observationRepository;
+        this.observationCursorRepository = observationCursorRepository;
+        this.observationLockRepository = observationLockRepository;
+        this.memoryEntryRepository = memoryEntryRepository;
+        this.memoryEntryLockRepository = memoryEntryLockRepository;
+        this.memoryEntrySourceRepository = memoryEntrySourceRepository;
+        this.memoryEntryCursorRepository = memoryEntryCursorRepository;
+        this.episodic = {
+            saveEntryWithSources: async (entry, sources) => await this.saveEpisodicMemoryEntryWithSources(entry, sources),
+            searchEntries: async (scope, query, opts) => await this.searchEpisodicMemoryEntries(scope, query, opts),
+            getEntrySources: async (entryIds) => await this.getEpisodicMemoryEntrySources(entryIds),
+            applyReflection: async (scope, reflection) => await this.applyEpisodicMemoryReflection(scope, reflection),
+            getCursor: async (scope) => await this.getEpisodicMemoryCursor(scope),
+            setCursor: async (cursor) => await this.setEpisodicMemoryCursor(cursor),
+            taskLock: {
+                acquire: async (resourceId, opts) => await this.acquireEpisodicMemoryTaskLock(resourceId, opts),
+                release: async (handle) => await this.releaseEpisodicMemoryTaskLock(handle),
+            },
+        };
     }
     async getThread(threadId) {
         const entity = await this.threadRepository.findOneBy({ id: threadId });
@@ -69,33 +125,50 @@ let N8nMemory = class N8nMemory {
     }
     async deleteThread(threadId) {
         await this.threadRepository.manager.transaction(async (trx) => {
-            const legacyScope = { scopeKind: 'thread', scopeId: threadId };
-            const resourceScope = {
-                scopeKind: 'thread',
-                scopeId: (0, typeorm_1.Like)(`${(0, agents_1.createObservationLogThreadScopePrefix)(threadId)}%`),
-            };
-            for (const scope of [legacyScope, resourceScope]) {
-                await trx.delete(agent_observation_entity_1.AgentObservationEntity, scope);
-                await trx.delete(agent_observation_cursor_entity_1.AgentObservationCursorEntity, scope);
-                await trx.delete(agent_observation_lock_entity_1.AgentObservationLockEntity, scope);
-            }
+            await this.dropEpisodicEntriesWithoutSources(trx, threadId);
+            const observationScope = { agentId: this.agentId, observationScopeId: threadId };
+            await trx.delete(agent_observation_entity_1.AgentObservationEntity, observationScope);
+            await trx.delete(agent_observation_cursor_entity_1.AgentObservationCursorEntity, observationScope);
+            await trx.delete(agent_observation_lock_entity_1.AgentObservationLockEntity, observationScope);
+            await trx.delete(agent_memory_entry_cursor_entity_1.AgentMemoryEntryCursorEntity, observationScope);
             await trx.delete(agent_thread_entity_1.AgentThreadEntity, { id: threadId });
         });
     }
     async deleteThreadsByPrefix(threadIdPrefix) {
-        const scopeId = (0, typeorm_1.Like)(`${threadIdPrefix}%`);
-        const resourceScopeId = (0, typeorm_1.Like)(`${(0, agents_1.createObservationLogThreadScopePrefix)(threadIdPrefix)}%`);
+        const observationScopeId = (0, typeorm_1.Like)(`${threadIdPrefix}%`);
         await this.threadRepository.manager.transaction(async (trx) => {
-            for (const scope of [
-                { scopeKind: 'thread', scopeId },
-                { scopeKind: 'thread', scopeId: resourceScopeId },
-            ]) {
-                await trx.delete(agent_observation_entity_1.AgentObservationEntity, scope);
-                await trx.delete(agent_observation_cursor_entity_1.AgentObservationCursorEntity, scope);
-                await trx.delete(agent_observation_lock_entity_1.AgentObservationLockEntity, scope);
-            }
-            await trx.delete(agent_thread_entity_1.AgentThreadEntity, { id: scopeId });
+            await this.dropEpisodicEntriesWithoutSources(trx, observationScopeId);
+            const observationScope = { agentId: this.agentId, observationScopeId };
+            await trx.delete(agent_observation_entity_1.AgentObservationEntity, observationScope);
+            await trx.delete(agent_observation_cursor_entity_1.AgentObservationCursorEntity, observationScope);
+            await trx.delete(agent_observation_lock_entity_1.AgentObservationLockEntity, observationScope);
+            await trx.delete(agent_memory_entry_cursor_entity_1.AgentMemoryEntryCursorEntity, observationScope);
+            await trx.delete(agent_thread_entity_1.AgentThreadEntity, { id: observationScopeId });
+        });
+    }
+    async dropEpisodicEntriesWithoutSources(trx, threadId) {
+        const sourceRepo = trx.getRepository(agent_memory_entry_source_entity_1.AgentMemoryEntrySourceEntity);
+        const entryRepo = trx.getRepository(agent_memory_entry_entity_1.AgentMemoryEntryEntity);
+        const affectedSources = await sourceRepo.find({
+            select: { memoryEntryId: true },
+            where: { agentId: this.agentId, threadId },
         });
+        const affectedEntryIds = (0, agents_1.uniqueStrings)(affectedSources.map((source) => source.memoryEntryId));
+        if (affectedEntryIds.length === 0)
+            return;
+        await trx.delete(agent_memory_entry_source_entity_1.AgentMemoryEntrySourceEntity, {
+            agentId: this.agentId,
+            threadId,
+        });
+        const remainingSources = await sourceRepo.find({
+            select: { memoryEntryId: true },
+            where: { agentId: this.agentId, memoryEntryId: (0, typeorm_1.In)(affectedEntryIds) },
+        });
+        const entriesWithSources = new Set(remainingSources.map((source) => source.memoryEntryId));
+        const orphanedEntryIds = affectedEntryIds.filter((id) => !entriesWithSources.has(id));
+        if (orphanedEntryIds.length === 0)
+            return;
+        await entryRepo.update({ agentId: this.agentId, id: (0, typeorm_1.In)(orphanedEntryIds), status: 'active' }, (0, agents_1.droppedLifecycleState)());
     }
     async getMessages(threadId, opts) {
         const where = {
@@ -148,14 +221,13 @@ let N8nMemory = class N8nMemory {
         if (rows.length === 0)
             return [];
         const entities = rows.map((row) => this.observationRepository.create({
-            scopeKind: row.scopeKind,
-            scopeId: row.scopeId,
+            agentId: this.agentId,
+            observationScopeId: row.observationScopeId,
             marker: row.marker,
             text: row.text,
             parentId: row.parentId ?? null,
             tokenCount: row.tokenCount ?? estimateObservationTokens(row.text),
-            status: 'active',
-            supersededBy: null,
+            ...(0, agents_1.activeLifecycleState)(),
             createdAt: row.createdAt,
         }));
         const saved = await this.observationRepository.save(entities);
@@ -166,8 +238,8 @@ let N8nMemory = class N8nMemory {
     }
     async getObservationLog(opts) {
         const baseWhere = {
-            scopeKind: opts.scopeKind,
-            scopeId: opts.scopeId,
+            agentId: this.agentId,
+            observationScopeId: opts.observationScopeId,
             ...(opts.status !== undefined && { status: opts.status }),
             ...(opts.parentId !== undefined && { parentId: opts.parentId ?? (0, typeorm_1.IsNull)() }),
         };
@@ -181,13 +253,9 @@ let N8nMemory = class N8nMemory {
         });
         return entities.map((e) => this.toObservationLogEntry(e));
     }
-    async getMessagesForScope(scopeKind, scopeId, opts) {
-        if (scopeKind !== 'thread') {
-            throw new n8n_workflow_1.UnexpectedError(`getMessagesForScope: scopeKind='${scopeKind}' is not supported in observational memory v1`);
-        }
+    async getMessagesForObservationScope(observationScopeId, opts) {
         const baseWhere = {
-            threadId: scopeId,
-            ...(opts?.resourceId !== undefined && { resourceId: opts.resourceId }),
+            threadId: observationScopeId,
         };
         const where = opts?.since
             ? [
@@ -208,20 +276,20 @@ let N8nMemory = class N8nMemory {
     async dropObservationLogEntries(ids) {
         if (ids.length === 0)
             return;
-        await this.observationRepository.update({ id: (0, typeorm_1.In)(ids) }, { status: 'dropped', supersededBy: null });
+        await this.observationRepository.update({ id: (0, typeorm_1.In)(ids) }, (0, agents_1.droppedLifecycleState)());
     }
     async supersedeObservationLogEntries(ids, supersededBy) {
         if (ids.length === 0)
             return;
-        await this.observationRepository.update({ id: (0, typeorm_1.In)(ids) }, { status: 'superseded', supersededBy });
+        await this.observationRepository.update({ id: (0, typeorm_1.In)(ids) }, (0, agents_1.supersededLifecycleState)(supersededBy));
     }
     async applyObservationLogReflection(scope, reflection) {
         return await this.observationRepository.manager.transaction(async (trx) => {
             const repo = trx.getRepository(agent_observation_entity_1.AgentObservationEntity);
             const activeEntries = await repo.find({
                 where: {
-                    scopeKind: scope.scopeKind,
-                    scopeId: scope.scopeId,
+                    agentId: this.agentId,
+                    observationScopeId: scope.observationScopeId,
                     status: 'active',
                 },
                 order: { createdAt: 'ASC', id: 'ASC' },
@@ -229,24 +297,31 @@ let N8nMemory = class N8nMemory {
             const normalized = (0, agents_1.normalizeObservationLogReflection)(activeEntries.map((entry) => this.toObservationLogEntry(entry)), reflection);
             const inserted = normalized.merge.length
                 ? await repo.save(normalized.merge.map((entry) => repo.create({
-                    scopeKind: scope.scopeKind,
-                    scopeId: scope.scopeId,
+                    agentId: this.agentId,
+                    observationScopeId: scope.observationScopeId,
                     marker: entry.marker,
                     text: entry.text,
                     parentId: entry.parentId ?? null,
                     tokenCount: entry.tokenCount ?? estimateObservationTokens(entry.text),
-                    status: 'active',
-                    supersededBy: null,
+                    ...(0, agents_1.activeLifecycleState)(),
                     createdAt: entry.createdAt,
                 })))
                 : [];
             if (normalized.drop.length > 0) {
-                await repo.update({ scopeKind: scope.scopeKind, scopeId: scope.scopeId, id: (0, typeorm_1.In)(normalized.drop) }, { status: 'dropped', supersededBy: null });
+                await repo.update({
+                    agentId: this.agentId,
+                    observationScopeId: scope.observationScopeId,
+                    id: (0, typeorm_1.In)(normalized.drop),
+                }, (0, agents_1.droppedLifecycleState)());
             }
             for (const [index, merge] of normalized.merge.entries()) {
                 const replacement = inserted[index];
                 if (replacement && merge.supersedes.length > 0) {
-                    await repo.update({ scopeKind: scope.scopeKind, scopeId: scope.scopeId, id: (0, typeorm_1.In)(merge.supersedes) }, { status: 'superseded', supersededBy: replacement.id });
+                    await repo.update({
+                        agentId: this.agentId,
+                        observationScopeId: scope.observationScopeId,
+                        id: (0, typeorm_1.In)(merge.supersedes),
+                    }, (0, agents_1.supersededLifecycleState)(replacement.id));
                 }
             }
             return {
@@ -256,13 +331,15 @@ let N8nMemory = class N8nMemory {
             };
         });
     }
-    async getCursor(scopeKind, scopeId) {
-        const entity = await this.observationCursorRepository.findOneBy({ scopeKind, scopeId });
+    async getCursor(observationScopeId) {
+        const entity = await this.observationCursorRepository.findOneBy({
+            agentId: this.agentId,
+            observationScopeId,
+        });
         if (!entity)
             return null;
         return {
-            scopeKind: entity.scopeKind,
-            scopeId: entity.scopeId,
+            observationScopeId: entity.observationScopeId,
             lastObservedMessageId: entity.lastObservedMessageId,
             lastObservedAt: entity.lastObservedAt,
             updatedAt: entity.updatedAt,
@@ -270,57 +347,406 @@ let N8nMemory = class N8nMemory {
     }
     async setCursor(cursor) {
         await this.observationCursorRepository.upsert({
-            scopeKind: cursor.scopeKind,
-            scopeId: cursor.scopeId,
+            agentId: this.agentId,
+            observationScopeId: cursor.observationScopeId,
             lastObservedMessageId: cursor.lastObservedMessageId,
             lastObservedAt: cursor.lastObservedAt,
             updatedAt: cursor.updatedAt,
-        }, { conflictPaths: ['scopeKind', 'scopeId'], skipUpdateIfNoValuesChanged: false });
+        }, {
+            conflictPaths: ['agentId', 'observationScopeId'],
+            skipUpdateIfNoValuesChanged: false,
+        });
     }
-    async acquireObservationLogTaskLock(scopeKind, scopeId, taskKind, opts) {
+    async acquireObservationLogTaskLock(observationScopeId, taskKind, opts) {
         const now = new Date();
         const heldUntil = new Date(now.getTime() + opts.ttlMs);
         const updateResult = await this.observationLockRepository
             .createQueryBuilder()
             .update(agent_observation_lock_entity_1.AgentObservationLockEntity)
             .set({ taskKind, holderId: opts.holderId, heldUntil })
-            .where('"scopeKind" = :scopeKind')
-            .andWhere('"scopeId" = :scopeId')
+            .where('"agentId" = :agentId')
+            .andWhere('"observationScopeId" = :observationScopeId')
             .andWhere('"taskKind" = :taskKind')
             .andWhere('("holderId" = :holderId OR "heldUntil" <= :now)')
-            .setParameters({ scopeKind, scopeId, taskKind, holderId: opts.holderId, now })
+            .setParameters({
+            agentId: this.agentId,
+            observationScopeId,
+            taskKind,
+            holderId: opts.holderId,
+            now,
+        })
             .execute();
         if ((updateResult.affected ?? 0) > 0) {
-            return { scopeKind, scopeId, taskKind, holderId: opts.holderId, heldUntil };
+            return { observationScopeId, taskKind, holderId: opts.holderId, heldUntil };
         }
         await this.observationLockRepository
             .createQueryBuilder()
             .insert()
             .into(agent_observation_lock_entity_1.AgentObservationLockEntity)
-            .values({ scopeKind, scopeId, taskKind, holderId: opts.holderId, heldUntil })
+            .values({
+            agentId: this.agentId,
+            observationScopeId,
+            taskKind,
+            holderId: opts.holderId,
+            heldUntil,
+        })
             .orIgnore()
             .execute();
         const claimed = await this.observationLockRepository.findOneBy({
-            scopeKind,
-            scopeId,
+            agentId: this.agentId,
+            observationScopeId,
             taskKind,
             holderId: opts.holderId,
         });
         if (!claimed)
             return null;
-        return { scopeKind, scopeId, taskKind, holderId: opts.holderId, heldUntil };
+        return { observationScopeId, taskKind, holderId: opts.holderId, heldUntil };
     }
     async releaseObservationLogTaskLock(handle) {
         await this.releaseScopeLock(handle);
     }
     async releaseScopeLock(handle) {
         await this.observationLockRepository.delete({
-            scopeKind: handle.scopeKind,
-            scopeId: handle.scopeId,
+            agentId: this.agentId,
+            observationScopeId: handle.observationScopeId,
             taskKind: handle.taskKind,
             holderId: handle.holderId,
         });
     }
+    async acquireEpisodicMemoryTaskLock(resourceId, opts) {
+        await this.ensureResource(resourceId);
+        const now = new Date();
+        const heldUntil = new Date(now.getTime() + opts.ttlMs);
+        const updateResult = await this.memoryEntryLockRepository
+            .createQueryBuilder()
+            .update(agent_memory_entry_lock_entity_1.AgentMemoryEntryLockEntity)
+            .set({ holderId: opts.holderId, heldUntil })
+            .where('"agentId" = :agentId')
+            .andWhere('"resourceId" = :resourceId')
+            .andWhere('("holderId" = :holderId OR "heldUntil" <= :now)')
+            .setParameters({
+            agentId: this.agentId,
+            resourceId,
+            holderId: opts.holderId,
+            now,
+        })
+            .execute();
+        if ((updateResult.affected ?? 0) > 0) {
+            return { resourceId, holderId: opts.holderId, heldUntil };
+        }
+        await this.memoryEntryLockRepository
+            .createQueryBuilder()
+            .insert()
+            .into(agent_memory_entry_lock_entity_1.AgentMemoryEntryLockEntity)
+            .values({ agentId: this.agentId, resourceId, holderId: opts.holderId, heldUntil })
+            .orIgnore()
+            .execute();
+        const claimed = await this.memoryEntryLockRepository.findOneBy({
+            agentId: this.agentId,
+            resourceId,
+            holderId: opts.holderId,
+        });
+        if (!claimed)
+            return null;
+        return { resourceId, holderId: opts.holderId, heldUntil };
+    }
+    async releaseEpisodicMemoryTaskLock(handle) {
+        await this.memoryEntryLockRepository.delete({
+            agentId: this.agentId,
+            resourceId: handle.resourceId,
+            holderId: handle.holderId,
+        });
+    }
+    async saveEpisodicMemoryEntryWithSources(entry, sources) {
+        await this.ensureResource(entry.resourceId);
+        return await this.memoryEntryRepository.manager.transaction(async (trx) => {
+            const entryRepo = trx.getRepository(agent_memory_entry_entity_1.AgentMemoryEntryEntity);
+            const sourceRepo = trx.getRepository(agent_memory_entry_source_entity_1.AgentMemoryEntrySourceEntity);
+            const contentHash = entry.contentHash ?? (0, agents_1.hashEpisodicMemoryContent)(entry.content);
+            const now = new Date();
+            const entity = entryRepo.create({
+                agentId: this.agentId,
+                resourceId: entry.resourceId,
+                content: entry.content,
+                contentHash,
+                ...(0, agents_1.activeLifecycleState)(),
+                embeddingModel: entry.embeddingModel ?? null,
+                embedding: entry.embedding ?? null,
+                metadata: entry.metadata ?? null,
+                createdAt: entry.createdAt ?? now,
+                lastSeenAt: entry.lastSeenAt ?? now,
+            });
+            let persisted = null;
+            try {
+                const [saved] = await entryRepo.save([entity]);
+                persisted = saved ?? null;
+            }
+            catch (error) {
+                if (!(error instanceof Error) || !(0, response_helper_1.isUniqueConstraintError)(error))
+                    throw error;
+                const existing = await entryRepo.findOneBy({
+                    agentId: this.agentId,
+                    resourceId: entry.resourceId,
+                    contentHash,
+                });
+                if (!existing)
+                    throw error;
+                (0, agents_1.markLifecycleActive)(existing);
+                existing.lastSeenAt = entry.lastSeenAt ?? now;
+                existing.updatedAt = now;
+                const [saved] = await entryRepo.save([existing]);
+                persisted = saved ?? existing;
+            }
+            if (!persisted)
+                return null;
+            for (const source of sources) {
+                const evidenceHash = (0, agents_1.hashEpisodicMemoryEvidence)(source.evidenceText);
+                const sourceEntity = sourceRepo.create({
+                    agentId: this.agentId,
+                    memoryEntryId: persisted.id,
+                    observationId: source.observationId,
+                    threadId: source.threadId,
+                    evidenceHash,
+                    evidenceText: source.evidenceText,
+                    createdAt: source.createdAt,
+                });
+                try {
+                    await sourceRepo.save([sourceEntity]);
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || !(0, response_helper_1.isUniqueConstraintError)(error))
+                        throw error;
+                    const existing = await sourceRepo.findOneBy({
+                        agentId: this.agentId,
+                        memoryEntryId: persisted.id,
+                        observationId: source.observationId,
+                        evidenceHash,
+                    });
+                    if (!existing)
+                        throw error;
+                }
+            }
+            return this.toEpisodicMemoryEntry(persisted);
+        });
+    }
+    async searchEpisodicMemoryEntries(scope, query, opts) {
+        const statuses = opts?.includeStatuses ?? ['active'];
+        const entities = await this.memoryEntryRepository.find({
+            where: { agentId: this.agentId, resourceId: scope.resourceId, status: (0, typeorm_1.In)(statuses) },
+        });
+        return (0, agents_1.rankEpisodicMemoryEntries)(entities.map((entity) => this.toEpisodicMemoryEntry(entity)), query, opts);
+    }
+    async getEpisodicMemoryEntrySources(entryIds) {
+        if (entryIds.length === 0)
+            return [];
+        const entities = await this.memoryEntrySourceRepository.find({
+            where: { agentId: this.agentId, memoryEntryId: (0, typeorm_1.In)(entryIds) },
+            order: { createdAt: 'ASC', id: 'ASC' },
+        });
+        return entities.map((entity) => this.toEpisodicMemoryEntrySource(entity));
+    }
+    async applyEpisodicMemoryReflection(scope, reflection) {
+        return await this.memoryEntryRepository.manager.transaction(async (trx) => {
+            const entryRepo = trx.getRepository(agent_memory_entry_entity_1.AgentMemoryEntryEntity);
+            const sourceRepo = trx.getRepository(agent_memory_entry_source_entity_1.AgentMemoryEntrySourceEntity);
+            const actionIds = (0, agents_1.uniqueStrings)([
+                ...reflection.drop,
+                ...reflection.merge.flatMap((merge) => merge.supersedes),
+            ]);
+            if (actionIds.length === 0)
+                return { droppedIds: [], supersededIds: [], inserted: [] };
+            const activeEntries = await entryRepo.find({
+                where: {
+                    agentId: this.agentId,
+                    resourceId: scope.resourceId,
+                    id: (0, typeorm_1.In)(actionIds),
+                    status: 'active',
+                },
+            });
+            const activeIds = new Set(activeEntries.map((entry) => entry.id));
+            const normalized = (0, agents_1.normalizeFlatReflectionActions)({
+                activeIds,
+                drop: reflection.drop,
+                merge: reflection.merge,
+                normalizeMerge: (entry, supersedes) => ({ ...entry, supersedes }),
+            });
+            const now = new Date();
+            const replacementHashes = (0, agents_1.uniqueStrings)(normalized.merge.map((item) => item.entry.contentHash ?? (0, agents_1.hashEpisodicMemoryContent)(item.entry.content)));
+            const existingReplacements = replacementHashes.length
+                ? await entryRepo.find({
+                    where: {
+                        agentId: this.agentId,
+                        resourceId: scope.resourceId,
+                        contentHash: (0, typeorm_1.In)(replacementHashes),
+                    },
+                })
+                : [];
+            const existingByHash = new Map(existingReplacements.map((entry) => [entry.contentHash, entry]));
+            const replacements = [];
+            for (const item of normalized.merge) {
+                const contentHash = item.entry.contentHash ?? (0, agents_1.hashEpisodicMemoryContent)(item.entry.content);
+                const existing = existingByHash.get(contentHash);
+                const update = {
+                    ...(0, agents_1.activeLifecycleState)(),
+                    lastSeenAt: item.entry.lastSeenAt ?? now,
+                    updatedAt: now,
+                };
+                if (item.entry.embedding !== undefined)
+                    update.embedding = item.entry.embedding;
+                if (item.entry.embeddingModel !== undefined) {
+                    update.embeddingModel = item.entry.embeddingModel;
+                }
+                if (item.entry.metadata !== undefined)
+                    update.metadata = item.entry.metadata;
+                if (existing) {
+                    await entryRepo.update({ agentId: this.agentId, resourceId: scope.resourceId, id: existing.id }, update);
+                    replacements.push({
+                        ...existing,
+                        ...update,
+                    });
+                    continue;
+                }
+                const entity = entryRepo.create({
+                    agentId: this.agentId,
+                    resourceId: scope.resourceId,
+                    content: item.entry.content,
+                    contentHash,
+                    ...(0, agents_1.activeLifecycleState)(),
+                    embeddingModel: item.entry.embeddingModel ?? null,
+                    embedding: item.entry.embedding ?? null,
+                    metadata: item.entry.metadata ?? null,
+                    createdAt: item.entry.createdAt ?? now,
+                    lastSeenAt: item.entry.lastSeenAt ?? now,
+                });
+                try {
+                    const [persisted] = await entryRepo.save([entity]);
+                    if (persisted) {
+                        existingByHash.set(contentHash, persisted);
+                        replacements.push(persisted);
+                    }
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || !(0, response_helper_1.isUniqueConstraintError)(error))
+                        throw error;
+                    const persisted = await entryRepo.findOneBy({
+                        agentId: this.agentId,
+                        resourceId: scope.resourceId,
+                        contentHash,
+                    });
+                    if (!persisted)
+                        throw error;
+                    await entryRepo.update({ agentId: this.agentId, resourceId: scope.resourceId, id: persisted.id }, update);
+                    existingByHash.set(contentHash, persisted);
+                    replacements.push({
+                        ...persisted,
+                        ...update,
+                    });
+                }
+            }
+            const replacementIds = new Set(replacements.map((entry) => entry.id));
+            const effectiveDrop = normalized.drop.filter((id) => !replacementIds.has(id));
+            if (effectiveDrop.length > 0) {
+                await entryRepo.update({
+                    agentId: this.agentId,
+                    resourceId: scope.resourceId,
+                    id: (0, typeorm_1.In)(effectiveDrop),
+                    status: 'active',
+                }, (0, agents_1.droppedLifecycleState)());
+            }
+            const supersededIds = [];
+            for (const [index, item] of normalized.merge.entries()) {
+                const replacement = replacements[index];
+                if (!replacement)
+                    continue;
+                const sourceRows = await sourceRepo.find({
+                    where: { agentId: this.agentId, memoryEntryId: (0, typeorm_1.In)(item.supersedes) },
+                    order: { createdAt: 'ASC', id: 'ASC' },
+                });
+                const existingReplacementSources = await sourceRepo.find({
+                    where: { agentId: this.agentId, memoryEntryId: replacement.id },
+                });
+                const existingKeys = new Set(existingReplacementSources.map((source) => `${source.observationId}\n${source.evidenceHash}`));
+                const copiedSources = sourceRows.flatMap((source) => {
+                    const key = `${source.observationId}\n${source.evidenceHash}`;
+                    if (existingKeys.has(key))
+                        return [];
+                    existingKeys.add(key);
+                    return [
+                        sourceRepo.create({
+                            agentId: this.agentId,
+                            memoryEntryId: replacement.id,
+                            observationId: source.observationId,
+                            threadId: source.threadId,
+                            evidenceHash: source.evidenceHash,
+                            evidenceText: source.evidenceText,
+                            createdAt: now,
+                        }),
+                    ];
+                });
+                if (copiedSources.length > 0)
+                    await sourceRepo.save(copiedSources);
+                const itemSupersededIds = item.supersedes.filter((id) => id !== replacement.id);
+                if (itemSupersededIds.length > 0) {
+                    await entryRepo.update({
+                        agentId: this.agentId,
+                        resourceId: scope.resourceId,
+                        id: (0, typeorm_1.In)(itemSupersededIds),
+                        status: 'active',
+                    }, (0, agents_1.supersededLifecycleState)(replacement.id));
+                    supersededIds.push(...itemSupersededIds);
+                }
+            }
+            return {
+                droppedIds: effectiveDrop,
+                supersededIds,
+                inserted: replacements.map((entry) => this.toEpisodicMemoryEntry(entry)),
+            };
+        });
+    }
+    async getEpisodicMemoryCursor(scope) {
+        const entity = await this.memoryEntryCursorRepository.findOneBy({
+            agentId: this.agentId,
+            observationScopeId: scope.observationScopeId,
+        });
+        if (!entity)
+            return null;
+        return {
+            observationScopeId: entity.observationScopeId,
+            lastIndexedObservationId: entity.lastIndexedObservationId,
+            lastIndexedObservationCreatedAt: entity.lastIndexedObservationCreatedAt,
+            updatedAt: entity.updatedAt,
+        };
+    }
+    async setEpisodicMemoryCursor(cursor) {
+        const cursorRow = {
+            agentId: this.agentId,
+            observationScopeId: cursor.observationScopeId,
+            lastIndexedObservationId: cursor.lastIndexedObservationId,
+            lastIndexedObservationCreatedAt: cursor.lastIndexedObservationCreatedAt,
+            updatedAt: cursor.updatedAt ?? new Date(),
+        };
+        await this.memoryEntryCursorRepository
+            .createQueryBuilder()
+            .insert()
+            .into(agent_memory_entry_cursor_entity_1.AgentMemoryEntryCursorEntity)
+            .values(cursorRow)
+            .orIgnore()
+            .execute();
+        await this.memoryEntryCursorRepository
+            .createQueryBuilder()
+            .update(agent_memory_entry_cursor_entity_1.AgentMemoryEntryCursorEntity)
+            .set(cursorRow)
+            .where('"agentId" = :agentId')
+            .andWhere('"observationScopeId" = :observationScopeId')
+            .andWhere('("lastIndexedObservationCreatedAt" < :lastIndexedObservationCreatedAt OR ("lastIndexedObservationCreatedAt" = :lastIndexedObservationCreatedAt AND "lastIndexedObservationId" < :lastIndexedObservationId))')
+            .setParameters({
+            agentId: this.agentId,
+            observationScopeId: cursor.observationScopeId,
+            lastIndexedObservationId: cursor.lastIndexedObservationId,
+            lastIndexedObservationCreatedAt: cursor.lastIndexedObservationCreatedAt,
+        })
+            .execute();
+    }
     describe() {
         return { name: 'n8n', connectionParams: {}, constructorName: this.constructor.name };
     }
@@ -333,8 +759,7 @@ let N8nMemory = class N8nMemory {
     toObservationLogEntry(entity) {
         return {
             id: entity.id,
-            scopeKind: entity.scopeKind,
-            scopeId: entity.scopeId,
+            observationScopeId: entity.observationScopeId,
             marker: entity.marker,
             text: entity.text,
             parentId: entity.parentId,
@@ -344,6 +769,32 @@ let N8nMemory = class N8nMemory {
             createdAt: entity.createdAt,
         };
     }
+    toEpisodicMemoryEntry(entity) {
+        return {
+            id: entity.id,
+            resourceId: entity.resourceId,
+            content: entity.content,
+            contentHash: entity.contentHash,
+            status: entity.status,
+            supersededBy: entity.supersededBy,
+            ...(entity.embedding ? { embedding: entity.embedding } : {}),
+            ...(entity.embeddingModel ? { embeddingModel: entity.embeddingModel } : {}),
+            metadata: entity.metadata,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            lastSeenAt: entity.lastSeenAt,
+        };
+    }
+    toEpisodicMemoryEntrySource(entity) {
+        return {
+            id: entity.id,
+            memoryEntryId: entity.memoryEntryId,
+            observationId: entity.observationId,
+            threadId: entity.threadId,
+            evidenceText: entity.evidenceText,
+            createdAt: entity.createdAt,
+        };
+    }
     toThread(entity) {
         let metadata;
         if (entity.metadata) {
@@ -363,15 +814,6 @@ let N8nMemory = class N8nMemory {
             updatedAt: entity.updatedAt,
         };
     }
-};
-exports.N8nMemory = N8nMemory;
-exports.N8nMemory = N8nMemory = __decorate([
-    (0, di_1.Service)(),
-    __metadata("design:paramtypes", [agent_thread_repository_1.AgentThreadRepository,
-        agent_message_repository_1.AgentMessageRepository,
-        agent_resource_repository_1.AgentResourceRepository,
-        agent_observation_repository_1.AgentObservationRepository,
-        agent_observation_cursor_repository_1.AgentObservationCursorRepository,
-        agent_observation_lock_repository_1.AgentObservationLockRepository])
-], N8nMemory);
+}
+exports.N8nMemoryImpl = N8nMemoryImpl;
 //# sourceMappingURL=n8n-memory.js.map