n8n 2.14.2 → 2.16.0

package/dist/modules/instance-ai/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/instance-ai/storage/index.ts"],"names":[],"mappings":";;;AAAA,mEAAgE;AAAvD,8HAAA,oBAAoB,OAAA;AAC7B,yEAAsE;AAA7D,oIAAA,uBAAuB,OAAA;AAChC,qEAAkE;AAAzD,gIAAA,qBAAqB,OAAA;AAC9B,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,uEAAmE;AAA1D,iIAAA,qBAAqB,OAAA"}

package/dist/modules/instance-ai/storage/typeorm-composite-store.d.ts

@@ -0,0 +1,9 @@
+import { MastraCompositeStore } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
+import { TypeORMMemoryStorage } from './typeorm-memory-storage';
+import { TypeORMWorkflowsStorage } from './typeorm-workflows-storage';
+export declare class TypeORMCompositeStore extends MastraCompositeStore {
+    stores: StorageDomains;
+    constructor(memoryStorage: TypeORMMemoryStorage, workflowsStorage: TypeORMWorkflowsStorage);
+    init(): Promise<void>;
+}

package/dist/modules/instance-ai/storage/typeorm-composite-store.js

@@ -0,0 +1,33 @@
+"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.TypeORMCompositeStore = void 0;
+const di_1 = require("@n8n/di");
+const storage_1 = require("@mastra/core/storage");
+const typeorm_memory_storage_1 = require("./typeorm-memory-storage");
+const typeorm_workflows_storage_1 = require("./typeorm-workflows-storage");
+let TypeORMCompositeStore = class TypeORMCompositeStore extends storage_1.MastraCompositeStore {
+    constructor(memoryStorage, workflowsStorage) {
+        super({ id: 'n8n-instance-ai-store', disableInit: true });
+        this.stores = {
+            memory: memoryStorage,
+            workflows: workflowsStorage,
+        };
+    }
+    async init() {
+    }
+};
+exports.TypeORMCompositeStore = TypeORMCompositeStore;
+exports.TypeORMCompositeStore = TypeORMCompositeStore = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [typeorm_memory_storage_1.TypeORMMemoryStorage, typeorm_workflows_storage_1.TypeORMWorkflowsStorage])
+], TypeORMCompositeStore);
+//# sourceMappingURL=typeorm-composite-store.js.map

package/dist/modules/instance-ai/storage/typeorm-composite-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm-composite-store.js","sourceRoot":"","sources":["../../../../src/modules/instance-ai/storage/typeorm-composite-store.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,gCAAkC;AAClC,kDAA4D;AAG5D,qEAAgE;AAChE,2EAAsE;AAG/D,IAAM,qBAAqB,GAA3B,MAAM,qBAAsB,SAAQ,8BAAoB;IAG9D,YAAY,aAAmC,EAAE,gBAAyC;QACzF,KAAK,CAAC,EAAE,EAAE,EAAE,uBAAuB,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;QAG1D,IAAI,CAAC,MAAM,GAAG;YACb,MAAM,EAAE,aAAa;YACrB,SAAS,EAAE,gBAAgB;SACE,CAAC;IAChC,CAAC;IAEQ,KAAK,CAAC,IAAI;IAEnB,CAAC;CACD,CAAA;AAhBY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,YAAO,GAAE;qCAIkB,6CAAoB,EAAoB,mDAAuB;GAH9E,qBAAqB,CAgBjC"}

package/dist/modules/instance-ai/storage/typeorm-memory-storage.d.ts

@@ -0,0 +1,96 @@
+import type { MastraMessageContentV2 } from '@mastra/core/agent';
+import type { MastraDBMessage, StorageThreadType } from '@mastra/core/memory';
+import type { CreateObservationalMemoryInput, CreateReflectionGenerationInput, ObservationalMemoryRecord, StorageCloneThreadInput, StorageCloneThreadOutput, StorageListMessagesByResourceIdInput, StorageListMessagesInput, StorageListMessagesOutput, StorageListThreadsInput, StorageListThreadsOutput, StorageResourceType, SwapBufferedReflectionToActiveInput, SwapBufferedToActiveInput, SwapBufferedToActiveResult, UpdateBufferedReflectionInput, UpdateBufferedObservationsInput, UpdateActiveObservationsInput } from '@mastra/core/storage';
+import { MemoryStorage } from '@mastra/core/storage';
+import { InstanceAiMessageRepository } from '../repositories/instance-ai-message.repository';
+import { InstanceAiObservationalMemoryRepository } from '../repositories/instance-ai-observational-memory.repository';
+import { InstanceAiResourceRepository } from '../repositories/instance-ai-resource.repository';
+import { InstanceAiThreadRepository } from '../repositories/instance-ai-thread.repository';
+export declare class TypeORMMemoryStorage extends MemoryStorage {
+    private readonly threadRepo;
+    private readonly messageRepo;
+    private readonly resourceRepo;
+    private readonly omRepo;
+    readonly supportsObservationalMemory = true;
+    private static readonly threadMutationQueues;
+    constructor(threadRepo: InstanceAiThreadRepository, messageRepo: InstanceAiMessageRepository, resourceRepo: InstanceAiResourceRepository, omRepo: InstanceAiObservationalMemoryRepository);
+    dangerouslyClearAll(): Promise<void>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    listThreads(args: StorageListThreadsInput): Promise<StorageListThreadsOutput>;
+    saveThread({ thread, }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    patchThread({ threadId, update, }: {
+        threadId: string;
+        update: (current: StorageThreadType) => {
+            title?: string;
+            metadata?: Record<string, unknown>;
+        } | null | undefined;
+    }): Promise<StorageThreadType | null>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    private toStorageThread;
+    private serializeThreadMutation;
+    listMessages(args: StorageListMessagesInput): Promise<StorageListMessagesOutput>;
+    private getIncludedMessages;
+    listMessagesByResourceId(args: StorageListMessagesByResourceIdInput): Promise<StorageListMessagesOutput>;
+    listMessagesById({ messageIds, }: {
+        messageIds: string[];
+    }): Promise<{
+        messages: MastraDBMessage[];
+    }>;
+    saveMessages({ messages, }: {
+        messages: MastraDBMessage[];
+    }): Promise<{
+        messages: MastraDBMessage[];
+    }>;
+    updateMessages({ messages, }: {
+        messages: Array<Partial<Omit<MastraDBMessage, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        }>;
+    }): Promise<MastraDBMessage[]>;
+    deleteMessages(messageIds: string[]): Promise<void>;
+    getResourceById({ resourceId, }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource, }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    cloneThread(args: StorageCloneThreadInput): Promise<StorageCloneThreadOutput>;
+    private omLookupKey;
+    private entityToOMRecord;
+    getObservationalMemory(threadId: string | null, resourceId: string): Promise<ObservationalMemoryRecord | null>;
+    getObservationalMemoryHistory(threadId: string | null, resourceId: string, limit?: number): Promise<ObservationalMemoryRecord[]>;
+    initializeObservationalMemory(input: CreateObservationalMemoryInput): Promise<ObservationalMemoryRecord>;
+    insertObservationalMemoryRecord(record: ObservationalMemoryRecord): Promise<void>;
+    updateActiveObservations(input: UpdateActiveObservationsInput): Promise<void>;
+    updateBufferedObservations(input: UpdateBufferedObservationsInput): Promise<void>;
+    swapBufferedToActive(input: SwapBufferedToActiveInput): Promise<SwapBufferedToActiveResult>;
+    createReflectionGeneration(input: CreateReflectionGenerationInput): Promise<ObservationalMemoryRecord>;
+    updateBufferedReflection(input: UpdateBufferedReflectionInput): Promise<void>;
+    swapBufferedReflectionToActive(input: SwapBufferedReflectionToActiveInput): Promise<ObservationalMemoryRecord>;
+    setReflectingFlag(id: string, isReflecting: boolean): Promise<void>;
+    setObservingFlag(id: string, isObserving: boolean): Promise<void>;
+    setBufferingObservationFlag(id: string, isBuffering: boolean, lastBufferedAtTokens?: number): Promise<void>;
+    setBufferingReflectionFlag(id: string, isBuffering: boolean): Promise<void>;
+    clearObservationalMemory(threadId: string | null, resourceId: string): Promise<void>;
+    setPendingMessageTokens(id: string, tokenCount: number): Promise<void>;
+    private entityToMessage;
+}