n8n 2.14.2 → 2.16.0

package/dist/modules/instance-ai/instance-ai.module.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.InstanceAiModule = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+const YELLOW = '\x1b[33m';
+const CLEAR = '\x1b[0m';
+const WARNING_MESSAGE = "[Instance AI] 'instance-ai' module is experimental, undocumented and subject to change. " +
+    'Before its official release any features may become inaccessible at any point, ' +
+    'and using the module could compromise the stability of your system. Use at your own risk!';
+let InstanceAiModule = class InstanceAiModule {
+    async init() {
+        const logger = di_1.Container.get(backend_common_1.Logger).scoped('instance-ai');
+        logger.warn(`${YELLOW}${WARNING_MESSAGE}${CLEAR}`);
+        const { InstanceAiSettingsService } = await Promise.resolve().then(() => __importStar(require('./instance-ai-settings.service')));
+        await di_1.Container.get(InstanceAiSettingsService).loadFromDb();
+        await Promise.resolve().then(() => __importStar(require('./instance-ai.controller')));
+        const { InstanceAiMemoryService } = await Promise.resolve().then(() => __importStar(require('./instance-ai-memory.service')));
+        const { InstanceAiService } = await Promise.resolve().then(() => __importStar(require('./instance-ai.service')));
+        const aiService = di_1.Container.get(InstanceAiService);
+        void di_1.Container.get(InstanceAiMemoryService)
+            .cleanupExpiredThreads(async (threadId) => await aiService.clearThreadState(threadId))
+            .catch(() => undefined);
+        await Promise.resolve().then(() => __importStar(require('./snapshot-pruning.service')));
+    }
+    async settings() {
+        const { InstanceAiService } = await Promise.resolve().then(() => __importStar(require('./instance-ai.service')));
+        const { InstanceAiSettingsService } = await Promise.resolve().then(() => __importStar(require('./instance-ai-settings.service')));
+        const service = di_1.Container.get(InstanceAiService);
+        const settingsService = di_1.Container.get(InstanceAiSettingsService);
+        const enabled = service.isEnabled();
+        const localGateway = service.isLocalFilesystemAvailable();
+        const localGatewayDisabled = settingsService.isLocalGatewayDisabled();
+        const localGatewayFallbackDirectory = service.getLocalFilesystemDirectory();
+        return {
+            enabled,
+            localGateway,
+            localGatewayDisabled,
+            localGatewayFallbackDirectory,
+            proxyEnabled: service.isProxyEnabled(),
+        };
+    }
+    async entities() {
+        const { InstanceAiThread } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-thread.entity')));
+        const { InstanceAiMessage } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-message.entity')));
+        const { InstanceAiResource } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-resource.entity')));
+        const { InstanceAiObservationalMemory } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-observational-memory.entity')));
+        const { InstanceAiWorkflowSnapshot } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-workflow-snapshot.entity')));
+        const { InstanceAiRunSnapshot } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-run-snapshot.entity')));
+        const { InstanceAiIterationLog } = await Promise.resolve().then(() => __importStar(require('./entities/instance-ai-iteration-log.entity')));
+        return [
+            InstanceAiThread,
+            InstanceAiMessage,
+            InstanceAiResource,
+            InstanceAiObservationalMemory,
+            InstanceAiWorkflowSnapshot,
+            InstanceAiRunSnapshot,
+            InstanceAiIterationLog,
+        ];
+    }
+    async shutdown() {
+        const { InstanceAiService } = await Promise.resolve().then(() => __importStar(require('./instance-ai.service')));
+        await di_1.Container.get(InstanceAiService).shutdown();
+    }
+};
+exports.InstanceAiModule = InstanceAiModule;
+__decorate([
+    (0, decorators_1.OnShutdown)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], InstanceAiModule.prototype, "shutdown", null);
+exports.InstanceAiModule = InstanceAiModule = __decorate([
+    (0, decorators_1.BackendModule)({ name: 'instance-ai', instanceTypes: ['main'] })
+], InstanceAiModule);
+//# sourceMappingURL=instance-ai.module.js.map

package/dist/modules/instance-ai/instance-ai.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-ai.module.js","sourceRoot":"","sources":["../../../src/modules/instance-ai/instance-ai.module.ts"],"names":[],"mappings":"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"}

package/dist/modules/instance-ai/instance-ai.service.d.ts

@@ -0,0 +1,132 @@
+import { type InstanceAiAttachment, type InstanceAiThreadStatusResponse, type InstanceAiGatewayCapabilities, type McpToolCallResult, type ToolCategory } from '@n8n/api-types';
+import { Logger } from '@n8n/backend-common';
+import { GlobalConfig } from '@n8n/config';
+import type { User } from '@n8n/db';
+import { UrlService } from '../../services/url.service';
+import { type ConfirmationData } from '@n8n/instance-ai';
+import { AiService } from '../../services/ai.service';
+import { Push } from '../../push';
+import { InProcessEventBus } from './event-bus/in-process-event-bus';
+import type { LocalGateway } from './filesystem';
+import { InstanceAiSettingsService } from './instance-ai-settings.service';
+import { InstanceAiAdapterService } from './instance-ai.adapter.service';
+import { TypeORMCompositeStore } from './storage/typeorm-composite-store';
+import { DbSnapshotStorage } from './storage/db-snapshot-storage';
+import { DbIterationLogStorage } from './storage/db-iteration-log-storage';
+import { InstanceAiCompactionService } from './compaction.service';
+import { InstanceAiThreadRepository } from './repositories/instance-ai-thread.repository';
+export declare class InstanceAiService {
+    private readonly adapterService;
+    private readonly eventBus;
+    private readonly settingsService;
+    private readonly compositeStore;
+    private readonly compactionService;
+    private readonly aiService;
+    private readonly push;
+    private readonly threadRepo;
+    private readonly urlService;
+    private readonly dbSnapshotStorage;
+    private readonly dbIterationLogStorage;
+    private readonly mcpClientManager;
+    private readonly instanceAiConfig;
+    private readonly oauth2CallbackUrl;
+    private readonly webhookBaseUrl;
+    private readonly runState;
+    private readonly backgroundTasks;
+    private readonly traceContextsByRunId;
+    private readonly sandboxes;
+    private localFsProvider?;
+    private readonly gatewayRegistry;
+    private readonly domainAccessTrackersByThread;
+    private readonly threadPushRef;
+    private confirmationTimeoutInterval?;
+    private readonly creditedThreads;
+    private readonly defaultTimeZone;
+    private readonly logger;
+    constructor(logger: Logger, globalConfig: GlobalConfig, adapterService: InstanceAiAdapterService, eventBus: InProcessEventBus, settingsService: InstanceAiSettingsService, compositeStore: TypeORMCompositeStore, compactionService: InstanceAiCompactionService, aiService: AiService, push: Push, threadRepo: InstanceAiThreadRepository, urlService: UrlService, dbSnapshotStorage: DbSnapshotStorage, dbIterationLogStorage: DbIterationLogStorage);
+    private startConfirmationTimeoutSweep;
+    private getSandboxConfigFromEnv;
+    private resolveSandboxConfig;
+    private createBuilderFactory;
+    private getLocalFsProvider;
+    private getOrCreateWorkspace;
+    private destroySandbox;
+    private getProxyAuth;
+    private resolveModel;
+    private resolveSearchProxyConfig;
+    private resolveTracingProxyConfig;
+    private countCreditsIfFirst;
+    isProxyEnabled(): boolean;
+    getCredits(user: User): Promise<{
+        creditsQuota: number;
+        creditsClaimed: number;
+    }>;
+    isEnabled(): boolean;
+    isLocalFilesystemAvailable(): boolean;
+    getLocalFilesystemDirectory(): string | null;
+    hasActiveRun(threadId: string): boolean;
+    getThreadStatus(threadId: string): InstanceAiThreadStatusResponse;
+    private storeTraceContext;
+    private getTraceContext;
+    private finalizeMessageTraceRoot;
+    private maybeFinalizeRunTraceRoot;
+    private finalizeRemainingMessageTraceRoots;
+    private deleteTraceContextsForThread;
+    private finalizeDetachedTraceRun;
+    private finalizeRunTracing;
+    private finalizeBackgroundTaskTracing;
+    startRun(user: User, threadId: string, message: string, researchMode?: boolean, attachments?: InstanceAiAttachment[], timeZone?: string, pushRef?: string): string;
+    getMessageGroupId(threadId: string): string | undefined;
+    getLiveMessageGroupId(threadId: string): string | undefined;
+    getRunIdsForMessageGroup(messageGroupId: string): string[];
+    getActiveRunId(threadId: string): string | undefined;
+    cancelRun(threadId: string): void;
+    sendCorrectionToTask(threadId: string, taskId: string, correction: string): 'queued' | 'task-completed' | 'task-not-found';
+    cancelBackgroundTask(threadId: string, taskId: string): void;
+    getUserIdForApiKey(key: string): string | undefined;
+    generatePairingToken(userId: string): string;
+    getPairingToken(userId: string): string | null;
+    consumePairingToken(userId: string, token: string): string | null;
+    getActiveSessionKey(userId: string): string | null;
+    clearActiveSessionKey(userId: string): void;
+    getLocalGateway(userId: string): LocalGateway;
+    initGateway(userId: string, data: InstanceAiGatewayCapabilities): void;
+    resolveGatewayRequest(userId: string, requestId: string, result?: McpToolCallResult, error?: string): boolean;
+    disconnectGateway(userId: string): void;
+    isLocalGatewayDisabled(): boolean;
+    getGatewayStatus(userId: string): {
+        connected: boolean;
+        connectedAt: string | null;
+        directory: string | null;
+        hostIdentifier: string | null;
+        toolCategories: ToolCategory[];
+    };
+    startDisconnectTimer(userId: string, onDisconnect: () => void): void;
+    clearDisconnectTimer(userId: string): void;
+    clearThreadState(threadId: string): Promise<void>;
+    shutdown(): Promise<void>;
+    private createMemoryConfig;
+    private ensureThreadExists;
+    private projectPlannedTaskList;
+    private buildPlannedTaskFollowUpMessage;
+    private createPlannedTaskState;
+    private syncPlannedTasksToUi;
+    private createExecutionEnvironment;
+    private dispatchPlannedTask;
+    private createPlannedTaskContext;
+    private handlePlannedTaskSettlement;
+    private startInternalFollowUpRun;
+    private schedulePlannedTasks;
+    private executeRun;
+    resolveConfirmation(requestingUserId: string, requestId: string, data: ConfirmationData): Promise<boolean>;
+    private resumeSuspendedRun;
+    private processResumedStream;
+    private spawnBackgroundTask;
+    private buildMessageWithRunningTasks;
+    private publishRunFinish;
+    private finalizeRun;
+    private refineTitleIfNeeded;
+    private cleanupMastraSnapshots;
+    private saveAgentTreeSnapshot;
+    private parseMcpServers;
+}