n8n 2.29.6 → 2.30.0

package/dist/modules/agents/agent-knowledge-sandbox.service.js

@@ -14,6 +14,7 @@ const agents_1 = require("@n8n/agents");
 const sandbox_1 = require("@n8n/agents/sandbox");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
+const constants_1 = require("@n8n/constants");
 const di_1 = require("@n8n/di");
 const n8n_core_1 = require("n8n-core");
 const n8n_workflow_1 = require("n8n-workflow");
@@ -22,20 +23,18 @@ const node_crypto_1 = require("node:crypto");
 const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
 const not_found_error_1 = require("../../errors/response-errors/not-found.error");
 const ai_service_1 = require("../../services/ai.service");
+const ttl_map_1 = require("../../utils/ttl-map");
 const agent_knowledge_commands_1 = require("./agent-knowledge-commands");
 const agent_knowledge_gate_1 = require("./agent-knowledge-gate");
 const agent_knowledge_retrieval_1 = require("./agent-knowledge-retrieval");
 const agent_knowledge_storage_1 = require("./agent-knowledge-storage");
 const agent_file_repository_1 = require("./repositories/agent-file.repository");
 const agent_repository_1 = require("./repositories/agent.repository");
-exports.AGENT_KNOWLEDGE_SANDBOX_NAME_PREFIX = 'agents-knowledgebase';
+exports.AGENT_KNOWLEDGE_SANDBOX_NAME_PREFIX = 'agent-';
 const MAX_SANDBOX_ERROR_DETAIL_CHARS = 2_000;
 const LABEL_KNOWLEDGE_BASE = 'n8n-agents-knowledgebase';
 const LABEL_PROJECT_ID = 'n8n-project-id';
 const LABEL_AGENT_ID = 'n8n-agent-id';
-const LABEL_USER_ID = 'n8n-user-id';
-const LABEL_SANDBOX_SCOPE_ID = 'n8n-agents-sandbox-scope-id';
-const SANDBOX_SCOPE_LABEL_MAX_LEN = 63;
 const SANDBOX_STATE_STARTED = 'started';
 const DEAD_SANDBOX_STATES = new Set([
     'destroyed',
@@ -45,7 +44,9 @@ const DEAD_SANDBOX_STATES = new Set([
 ]);
 const DEFAULT_SANDBOX_IMAGE = 'daytonaio/sandbox:0.5.0';
 const AUTO_STOP_INTERVAL_MINUTES = 5;
-const SANDBOX_LIST_PAGE_SIZE = 100;
+const MIRROR_MANIFEST_HASH_TTL_MS = 30 * constants_1.Time.minutes.toMilliseconds;
+const MIRROR_DISK_FIT_WARNING_BYTES = 2 * 1024 * 1024 * 1024;
+const MIRROR_UPLOAD_BATCH_BYTES = 64 * 1024 * 1024;
 function emptySearchKnowledgeResult(outputMode, limit) {
     if (outputMode === 'files_with_matches') {
         return { outputMode, files: [], limit, hasMore: false, truncated: false };
@@ -55,61 +56,43 @@ function emptySearchKnowledgeResult(outputMode, limit) {
     }
     return { outputMode, matches: [], limit, hasMore: false, truncated: false };
 }
-function buildSandboxScopeKey(projectId, agentId, ownerUserId, sandboxScopeId) {
-    return `${projectId}:${agentId}:${ownerUserId}:${normalizeSandboxScopeLabel(sandboxScopeId)}`;
+function buildSandboxScopeKey(projectId, agentId) {
+    return `${projectId}:${agentId}`;
 }
 function buildSandboxName(scope) {
-    const hash = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(scope)).digest('hex').slice(0, 32);
-    return `${exports.AGENT_KNOWLEDGE_SANDBOX_NAME_PREFIX}-${hash}`;
+    return `${exports.AGENT_KNOWLEDGE_SANDBOX_NAME_PREFIX}${scope.instanceId}-${scope.projectId}-${scope.agentId}`.toLowerCase();
+}
+function extractCommandOutput(result) {
+    return result.artifacts?.stdout ?? result.result ?? '';
+}
+function parseManifestNames(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function hashManifestNames(names) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify([...names].sort()))
+        .digest('hex');
 }
 function isDaytonaNotFoundError(error) {
     const { DaytonaNotFoundError } = (0, sandbox_1.loadDaytona)();
     return error instanceof DaytonaNotFoundError;
 }
-function buildScopeLabels(projectId, agentId, ownerUserId, sandboxScopeId) {
+function buildScopeLabels(projectId, agentId) {
     return {
         [LABEL_KNOWLEDGE_BASE]: 'true',
         [LABEL_PROJECT_ID]: projectId,
         [LABEL_AGENT_ID]: agentId,
-        [LABEL_USER_ID]: ownerUserId,
-        [LABEL_SANDBOX_SCOPE_ID]: normalizeSandboxScopeLabel(sandboxScopeId),
     };
 }
-function normalizeSandboxScopeLabel(scopeId) {
-    const normalized = scopeId
-        .replace(/[^A-Za-z0-9_.-]+/g, '-')
-        .replace(/^[-.]+|[-.]+$/g, '')
-        .replace(/[-.]+/g, '-');
-    const digest = (0, node_crypto_1.createHash)('sha256').update(scopeId).digest('hex').slice(0, 8);
-    if (!normalized) {
-        return `scope-${digest}`;
-    }
-    if (normalized.length <= SANDBOX_SCOPE_LABEL_MAX_LEN && normalized === scopeId) {
-        return normalized;
-    }
-    const prefixMaxLen = SANDBOX_SCOPE_LABEL_MAX_LEN - digest.length - 1;
-    const prefix = normalized.slice(0, prefixMaxLen).replace(/[-.]+$/, '');
-    return prefix ? `${prefix}-${digest}` : `scope-${digest}`;
-}
-function isVolumeMountFailure(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /volume|mount|subpath/i.test(message);
-}
 function isUsableSandbox(sandbox) {
     const state = sandbox.state;
     if (!state)
         return true;
     return !DEAD_SANDBOX_STATES.has(state);
 }
-function hasMatchingVolumeMount(sandbox, expected) {
-    const volumes = sandbox.volumes ?? [];
-    return volumes.some((volume) => {
-        const mount = volume;
-        return (mount.volumeId === expected.volumeId &&
-            mount.mountPath === expected.mountPath &&
-            mount.subpath === expected.subpath);
-    });
-}
 function truncateSandboxErrorDetail(value) {
     if (value.length <= MAX_SANDBOX_ERROR_DETAIL_CHARS)
         return value;
@@ -132,26 +115,50 @@ function assertKnowledgeFilesDirectoryAvailable(operation, result) {
     throw new n8n_workflow_1.OperationalError(`Agent knowledge ${operation} failed because the uploaded knowledge files directory is unavailable in the sandbox`);
 }
 let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
-    constructor(agentsConfig, logger, aiService, instanceSettings, agentFileRepository, agentRepository) {
+    constructor(agentsConfig, logger, aiService, instanceSettings, agentFileRepository, agentRepository, binaryDataService) {
         this.agentsConfig = agentsConfig;
         this.logger = logger;
         this.aiService = aiService;
         this.instanceSettings = instanceSettings;
         this.agentFileRepository = agentFileRepository;
         this.agentRepository = agentRepository;
+        this.binaryDataService = binaryDataService;
         this.pendingSandboxAcquisitions = new Map();
+        this.mirrorManifestHashes = new ttl_map_1.TtlMap(MIRROR_MANIFEST_HASH_TTL_MS);
+        this.pendingMirrorSyncs = new Map();
     }
-    async withKnowledgeFilesystem(projectId, agentId, userId, operation) {
+    async warmSandbox(projectId, agentId) {
         this.assertKnowledgeConfiguration(projectId, agentId);
-        const sandbox = await this.acquireSandbox(projectId, agentId, userId);
-        const filesystem = this.createFilesystemAdapter(sandbox);
-        return await operation(filesystem);
+        await this.acquireSandbox(projectId, agentId);
     }
-    async warmSandbox(projectId, agentId, userId) {
-        this.assertKnowledgeConfiguration(projectId, agentId);
-        await this.acquireSandbox(projectId, agentId, userId);
+    async destroySandbox(projectId, agentId) {
+        if (!(0, agent_knowledge_gate_1.isAgentKnowledgeBaseEnabled)(this.agentsConfig))
+            return;
+        try {
+            const { Daytona } = (0, sandbox_1.loadDaytona)();
+            const connection = await this.resolveDaytonaConnection(projectId);
+            const daytona = new Daytona({
+                apiUrl: connection.apiUrl,
+                apiKey: connection.apiKey,
+            });
+            const name = buildSandboxName({
+                instanceId: this.instanceSettings.instanceId,
+                projectId,
+                agentId,
+            });
+            const timeoutSeconds = Math.ceil(this.agentsConfig.sandboxTimeout / 1000);
+            const sandbox = await daytona.get(name);
+            await sandbox.delete(timeoutSeconds);
+        }
+        catch (error) {
+            this.logger.warn('Failed to destroy agent knowledge sandbox', {
+                projectId,
+                agentId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
-    async searchKnowledge(projectId, agentId, userId, request) {
+    async searchKnowledge(projectId, agentId, request) {
         const validatedRequest = (0, agent_knowledge_retrieval_1.parseSearchKnowledgeRequest)(request);
         const references = await this.loadKnowledgeReferenceLookup(projectId, agentId);
         const outputMode = validatedRequest.output_mode ?? 'content';
@@ -160,7 +167,7 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             return emptySearchKnowledgeResult(outputMode, limit);
         }
         const scopedFilesByPath = new Map();
-        for (const path of validatedRequest.path) {
+        for (const path of validatedRequest.path ?? []) {
             const file = this.resolveOptionalFile({ file: path }, references);
             if (!file) {
                 throw new bad_request_error_1.BadRequestError('Knowledge file not found');
@@ -169,7 +176,7 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
         }
         const scopedFiles = [...scopedFilesByPath.values()];
         const command = (0, agent_knowledge_commands_1.buildSearchKnowledgeCommand)(validatedRequest, scopedFiles.map((file) => file.file));
-        const result = await this.executeKnowledgeOperation(projectId, agentId, userId, command);
+        const result = await this.executeKnowledgeOperation(projectId, agentId, command, references.files);
         assertKnowledgeFilesDirectoryAvailable('search', result);
         if (result.exitCode === 1) {
             return emptySearchKnowledgeResult(outputMode, limit);
@@ -209,26 +216,28 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             truncated: parsed.incomplete,
         };
     }
-    async globKnowledgeFiles(projectId, agentId, _userId, request) {
+    async globKnowledgeFiles(projectId, agentId, request) {
         const validatedRequest = (0, agent_knowledge_retrieval_1.parseGlobKnowledgeFilesRequest)(request);
         const references = await this.loadKnowledgeReferenceLookup(projectId, agentId);
         const limit = validatedRequest.limit ?? agent_knowledge_retrieval_1.DEFAULT_GLOB_FILES_LIMIT;
+        const offset = validatedRequest.offset ?? 0;
         if (references.files.length === 0) {
-            return { files: [], limit, hasMore: false };
+            return { files: [], limit, offset, hasMore: false };
         }
         const matches = matchKnowledgeFilesByGlob(references.files, validatedRequest);
         return {
-            files: matches.slice(0, limit),
+            files: matches.slice(offset, offset + limit),
             limit,
-            hasMore: matches.length > limit,
+            offset,
+            hasMore: matches.length > offset + limit,
         };
     }
-    async readKnowledge(projectId, agentId, userId, request) {
+    async readKnowledge(projectId, agentId, request) {
         const validatedRequest = (0, agent_knowledge_retrieval_1.parseReadKnowledgeRequest)(request);
         const references = await this.loadKnowledgeReferenceLookup(projectId, agentId);
         const file = this.resolveRequiredFile(validatedRequest, references);
         const command = (0, agent_knowledge_commands_1.buildReadKnowledgeCommand)(file.file, validatedRequest);
-        const result = await this.executeKnowledgeOperation(projectId, agentId, userId, command);
+        const result = await this.executeKnowledgeOperation(projectId, agentId, command, references.files);
         assertKnowledgeFilesDirectoryAvailable('read', result);
         if (result.exitCode !== 0) {
             throw new n8n_workflow_1.OperationalError(formatSandboxCommandFailure('read', result));
@@ -242,10 +251,16 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             truncated: parsed.truncated,
         };
     }
-    async executeKnowledgeOperation(projectId, agentId, userId, command) {
+    async executeKnowledgeOperation(projectId, agentId, command, files) {
         const timeoutSeconds = Math.ceil(this.agentsConfig.sandboxTimeout / 1000);
         const scopedCommand = (0, agent_knowledge_commands_1.buildScopedKnowledgeShellCommand)(command);
-        const sandbox = await this.acquireSandbox(projectId, agentId, userId);
+        const sandbox = await this.acquireSandbox(projectId, agentId);
+        const sandboxName = buildSandboxName({
+            instanceId: this.instanceSettings.instanceId,
+            projectId,
+            agentId,
+        });
+        await this.ensureMirrorSynced(sandbox, files, sandboxName);
         const result = await sandbox.process.executeCommand(scopedCommand, undefined, undefined, timeoutSeconds);
         return {
             exitCode: result.exitCode,
@@ -257,6 +272,128 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
                 : '',
         };
     }
+    async ensureMirrorSynced(sandbox, files, sandboxName) {
+        const expectedHash = hashManifestNames(files.map((file) => file.file));
+        if (this.mirrorManifestHashes.get(sandboxName) === expectedHash) {
+            return;
+        }
+        let pending = this.pendingMirrorSyncs.get(sandboxName);
+        if (!pending) {
+            pending = this.syncMirror(sandbox, files, expectedHash, sandboxName).finally(() => {
+                this.pendingMirrorSyncs.delete(sandboxName);
+            });
+            this.pendingMirrorSyncs.set(sandboxName, pending);
+        }
+        await pending;
+    }
+    async syncMirror(sandbox, files, expectedHash, sandboxName) {
+        if (this.mirrorManifestHashes.get(sandboxName) === expectedHash)
+            return;
+        const manifestResult = await sandbox.process.executeCommand((0, agent_knowledge_commands_1.buildReadMirrorManifestCommand)(), undefined, undefined, agent_knowledge_commands_1.MIRROR_SYNC_TIMEOUT_SECONDS);
+        const present = parseManifestNames(extractCommandOutput(manifestResult));
+        const expectedNames = files.map((file) => file.file);
+        const expectedSet = new Set(expectedNames);
+        const presentSet = new Set(present);
+        const toCopy = expectedNames.filter((name) => !presentSet.has(name));
+        const toDelete = present.filter((name) => !expectedSet.has(name));
+        if (toCopy.length === 0 && toDelete.length === 0) {
+            this.mirrorManifestHashes.set(sandboxName, expectedHash);
+            return;
+        }
+        for (const name of [...expectedNames, ...toDelete]) {
+            (0, agent_knowledge_storage_1.assertKnowledgePathSegment)(name, 'knowledge mirror file name');
+        }
+        if (present.length === 0 && toCopy.length > 0) {
+            const totalBytes = files.reduce((total, file) => total + file.fileSizeBytes, 0);
+            if (totalBytes > MIRROR_DISK_FIT_WARNING_BYTES) {
+                this.logger.warn('Agent knowledge mirror copy exceeds the disk-fit guard threshold', {
+                    sandboxName,
+                    totalBytes,
+                });
+            }
+        }
+        const filesByName = new Map(files.map((file) => [file.file, file]));
+        const copiedNames = await this.uploadMirrorFiles(sandbox, toCopy, filesByName, sandboxName);
+        const finalManifestNames = expectedNames.filter((name) => copiedNames.has(name) || presentSet.has(name));
+        const syncResult = await sandbox.process.executeCommand((0, agent_knowledge_commands_1.buildMirrorFinalizeCommand)([...copiedNames], toDelete, finalManifestNames), undefined, undefined, agent_knowledge_commands_1.MIRROR_SYNC_TIMEOUT_SECONDS);
+        if (syncResult.exitCode !== 0) {
+            throw new n8n_workflow_1.OperationalError(`Agent knowledge mirror sync failed: exitCode=${syncResult.exitCode}; output=${sanitizeSandboxErrorDetail(extractCommandOutput(syncResult))}`);
+        }
+        this.mirrorManifestHashes.set(sandboxName, hashManifestNames(finalManifestNames));
+    }
+    async uploadMirrorFiles(sandbox, names, filesByName, sandboxName) {
+        const copiedNames = new Set();
+        if (names.length === 0)
+            return copiedNames;
+        await sandbox.fs.createFolder(agent_knowledge_storage_1.KNOWLEDGE_MIRROR_FILES_DIR, '755');
+        let batch = [];
+        let batchNames = [];
+        let batchBytes = 0;
+        const flushBatch = async () => {
+            if (batch.length === 0)
+                return;
+            await sandbox.fs.uploadFiles(batch);
+            for (const name of batchNames)
+                copiedNames.add(name);
+            batch = [];
+            batchNames = [];
+            batchBytes = 0;
+        };
+        for (const name of names) {
+            const file = filesByName.get(name);
+            if (!file)
+                continue;
+            try {
+                const buffer = await this.binaryDataService.getAsBuffer({
+                    id: file.binaryDataId,
+                    data: '',
+                    mimeType: file.mimeType,
+                });
+                batch.push({ source: buffer, destination: `${agent_knowledge_storage_1.KNOWLEDGE_MIRROR_FILES_DIR}/.tmp-${name}` });
+                batchNames.push(name);
+                batchBytes += buffer.length;
+            }
+            catch (error) {
+                this.logger.warn('Failed to load agent knowledge file for mirror sync', {
+                    sandboxName,
+                    file: name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                continue;
+            }
+            if (batchBytes >= MIRROR_UPLOAD_BATCH_BYTES) {
+                await flushBatch();
+            }
+        }
+        await flushBatch();
+        return copiedNames;
+    }
+    prewarmMirrorInBackground(projectId, agentId) {
+        void (async () => {
+            const references = await this.loadKnowledgeReferenceLookup(projectId, agentId);
+            const sandbox = await this.acquireSandbox(projectId, agentId);
+            const sandboxName = buildSandboxName({
+                instanceId: this.instanceSettings.instanceId,
+                projectId,
+                agentId,
+            });
+            await this.ensureMirrorSynced(sandbox, references.files, sandboxName);
+        })().catch((error) => {
+            this.logger.warn('Agent knowledge mirror pre-warm failed', {
+                projectId,
+                agentId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+    invalidateMirror(projectId, agentId) {
+        const sandboxName = buildSandboxName({
+            instanceId: this.instanceSettings.instanceId,
+            projectId,
+            agentId,
+        });
+        this.mirrorManifestHashes.delete(sandboxName);
+    }
     async loadKnowledgeReferenceLookup(projectId, agentId) {
         await this.assertKnowledgeAccess(projectId, agentId);
         const files = await this.loadKnowledgeFileReferences(agentId);
@@ -269,8 +406,9 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
     async loadKnowledgeFileReferences(agentId) {
         const files = await this.agentFileRepository.findByAgentId(agentId);
         return files.map((file) => ({
-            file: (0, agent_knowledge_storage_1.fromVolumeStorageReference)(file.binaryDataId),
+            file: (0, agent_knowledge_storage_1.storageFileNameForOriginalFileName)(file.fileName),
             fileId: file.id,
+            binaryDataId: file.binaryDataId,
             displayName: file.fileName,
             mimeType: file.mimeType,
             fileSizeBytes: file.fileSizeBytes,
@@ -310,62 +448,43 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
         }
         return file;
     }
-    createFilesystemAdapter(sandbox) {
-        return {
-            uploadFiles: async (files) => {
-                if (files.length === 0) {
-                    return;
-                }
-                await sandbox.fs.uploadFiles(files.map((file) => ({ source: file.source, destination: file.destination })));
-            },
-            deleteFile: async (filePath, recursive) => await sandbox.fs.deleteFile(filePath, recursive),
-            ensureDir: async (dirPath) => await sandbox.fs.createFolder(dirPath, '755'),
-        };
-    }
-    async acquireSandbox(projectId, agentId, ownerUserId, sandboxScopeId = ownerUserId) {
-        const cacheKey = buildSandboxScopeKey(projectId, agentId, ownerUserId, sandboxScopeId);
+    async acquireSandbox(projectId, agentId) {
+        const cacheKey = buildSandboxScopeKey(projectId, agentId);
         let pending = this.pendingSandboxAcquisitions.get(cacheKey);
         if (!pending) {
-            pending = this.acquireSandboxFresh(projectId, agentId, ownerUserId, sandboxScopeId).finally(() => {
+            pending = this.acquireSandboxFresh(projectId, agentId).finally(() => {
                 this.pendingSandboxAcquisitions.delete(cacheKey);
             });
             this.pendingSandboxAcquisitions.set(cacheKey, pending);
         }
         return await pending;
     }
-    async acquireSandboxFresh(projectId, agentId, ownerUserId, sandboxScopeId) {
+    async acquireSandboxFresh(projectId, agentId) {
+        const agent = await this.agentRepository.findByIdAndProjectId(agentId, projectId);
+        if (!agent) {
+            throw new not_found_error_1.NotFoundError(`Agent "${agentId}" not found`);
+        }
+        if (agent.activeVersionId === null) {
+            throw new n8n_workflow_1.OperationalError('Knowledge base is only available for published agents. Publish the agent first.');
+        }
         const { Daytona } = (0, sandbox_1.loadDaytona)();
-        const connection = await this.resolveDaytonaConnection(ownerUserId);
+        const connection = await this.resolveDaytonaConnection(projectId);
         const daytona = new Daytona({
             apiUrl: connection.apiUrl,
             apiKey: connection.apiKey,
         });
-        const labels = buildScopeLabels(projectId, agentId, ownerUserId, sandboxScopeId);
+        const labels = buildScopeLabels(projectId, agentId);
         const timeoutSeconds = Math.ceil(this.agentsConfig.sandboxTimeout / 1000);
-        const volumeMount = this.buildVolumeMount(projectId, agentId);
         const name = buildSandboxName({
             instanceId: this.instanceSettings.instanceId,
             projectId,
             agentId,
-            ownerUserId,
-            sandboxScopeId,
         });
-        const sandboxByName = await this.resolveSandboxByName(daytona, name, volumeMount, timeoutSeconds, connection);
+        const sandboxByName = await this.resolveSandboxByName(daytona, name, timeoutSeconds, connection);
         if (sandboxByName) {
             this.logger.debug('Reused agent knowledge sandbox', { projectId, agentId, name });
             return sandboxByName;
         }
-        for await (const sandbox of daytona.list({ labels, limit: SANDBOX_LIST_PAGE_SIZE })) {
-            if (!isUsableSandbox(sandbox) || !hasMatchingVolumeMount(sandbox, volumeMount)) {
-                continue;
-            }
-            if (sandbox.state !== SANDBOX_STATE_STARTED) {
-                await sandbox.start(timeoutSeconds);
-            }
-            const reusableSandbox = await this.resolveReusableSandbox(daytona, sandbox, connection);
-            this.logger.debug('Reused agent knowledge sandbox', { projectId, agentId });
-            return reusableSandbox;
-        }
         const image = connection.image;
         const baseCreateParams = {
             name,
@@ -373,39 +492,29 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             language: 'typescript',
             ephemeral: this.agentsConfig.sandboxEphemeral,
             autoStopInterval: AUTO_STOP_INTERVAL_MINUTES,
-            volumes: [volumeMount],
         };
         let sandbox;
-        try {
-            if (connection.snapshot) {
-                try {
-                    sandbox = await daytona.create({ ...baseCreateParams, snapshot: connection.snapshot }, { timeout: timeoutSeconds });
-                }
-                catch (error) {
-                    this.logger.warn('Agent knowledge sandbox create from snapshot failed; falling back to image', {
-                        projectId,
-                        agentId,
-                        snapshotName: connection.snapshot,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    sandbox = await daytona.create({ ...baseCreateParams, image }, { timeout: timeoutSeconds });
-                }
+        if (connection.snapshot) {
+            try {
+                sandbox = await daytona.create({ ...baseCreateParams, snapshot: connection.snapshot }, { timeout: timeoutSeconds });
             }
-            else {
+            catch (error) {
+                this.logger.warn('Agent knowledge sandbox create from snapshot failed; falling back to image', {
+                    projectId,
+                    agentId,
+                    snapshotName: connection.snapshot,
+                    error: error instanceof Error ? error.message : String(error),
+                });
                 sandbox = await daytona.create({ ...baseCreateParams, image }, { timeout: timeoutSeconds });
             }
         }
-        catch (error) {
-            if (connection.mode === 'proxy' && isVolumeMountFailure(error)) {
-                const message = error instanceof Error ? error.message : String(error);
-                throw new n8n_workflow_1.OperationalError(`Agent knowledge sandbox creation failed through the AI Assistant sandbox proxy: ${message}. If the proxy does not support volume mounts, enable them before using the agent knowledge base.`, { cause: error });
-            }
-            throw error;
+        else {
+            sandbox = await daytona.create({ ...baseCreateParams, image }, { timeout: timeoutSeconds });
         }
         this.logger.debug('Created agent knowledge sandbox', { projectId, agentId, name });
         return sandbox;
     }
-    async resolveDaytonaConnection(userId) {
+    async resolveDaytonaConnection(projectId) {
         const directImage = this.agentsConfig.sandboxImage || DEFAULT_SANDBOX_IMAGE;
         const snapshot = this.agentsConfig.sandboxSnapshot.trim() || undefined;
         if (!this.aiService.isProxyEnabled()) {
@@ -419,7 +528,7 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
         }
         const client = await this.aiService.getClient();
         const proxyConfig = await client.getSandboxProxyConfig();
-        const token = await client.getBuilderApiProxyToken({ id: userId }, { userMessageId: (0, nanoid_1.nanoid)() });
+        const token = await client.getBuilderApiProxyToken({ id: projectId }, { userMessageId: (0, nanoid_1.nanoid)() });
         return {
             mode: 'proxy',
             apiUrl: client.getSandboxProxyBaseUrl(),
@@ -428,14 +537,7 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             snapshot,
         };
     }
-    buildVolumeMount(projectId, agentId) {
-        return {
-            volumeId: this.agentsConfig.daytonaVolumeId,
-            mountPath: agent_knowledge_storage_1.AGENT_KNOWLEDGE_VOLUME_MOUNT_PATH,
-            subpath: (0, agent_knowledge_storage_1.buildKnowledgeVolumeSubpath)(this.instanceSettings.instanceId, projectId, agentId),
-        };
-    }
-    async resolveSandboxByName(daytona, name, volumeMount, timeoutSeconds, connection) {
+    async resolveSandboxByName(daytona, name, timeoutSeconds, connection) {
         let sandbox;
         try {
             sandbox = await daytona.get(name);
@@ -450,9 +552,6 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
             await sandbox.delete(timeoutSeconds);
             return undefined;
         }
-        if (!hasMatchingVolumeMount(sandbox, volumeMount)) {
-            throw new n8n_workflow_1.OperationalError('Agent knowledge sandbox has an unexpected volume mount');
-        }
         if (sandbox.state !== SANDBOX_STATE_STARTED) {
             await sandbox.start(timeoutSeconds);
         }
@@ -489,11 +588,6 @@ let AgentKnowledgeSandboxService = class AgentKnowledgeSandboxService {
         if ((0, agent_knowledge_gate_1.isAgentKnowledgeBaseEnabled)(this.agentsConfig)) {
             return;
         }
-        if (this.agentsConfig.sandboxEnabled &&
-            this.agentsConfig.sandboxProvider === 'daytona' &&
-            !this.agentsConfig.daytonaVolumeId.trim()) {
-            throw new n8n_workflow_1.OperationalError('Agent knowledge Daytona volume is not configured');
-        }
         throw new n8n_workflow_1.OperationalError('Agent knowledge sandbox is not enabled');
     }
 };
@@ -505,21 +599,20 @@ exports.AgentKnowledgeSandboxService = AgentKnowledgeSandboxService = __decorate
         ai_service_1.AiService,
         n8n_core_1.InstanceSettings,
         agent_file_repository_1.AgentFileRepository,
-        agent_repository_1.AgentRepository])
+        agent_repository_1.AgentRepository,
+        n8n_core_1.BinaryDataService])
 ], AgentKnowledgeSandboxService);
 function matchKnowledgeFilesByGlob(files, request) {
     const caseSensitive = request.caseSensitive === true;
     const regex = globPatternToRegExp(request.pattern, caseSensitive);
     const patternTokens = tokenizeKnowledgeFilePattern(request.pattern, caseSensitive);
     return files
-        .map((file, index) => ({ file, index }))
-        .filter(({ file }) => regex.test(file.file) || regex.test(file.displayName))
-        .map(({ file, index }) => ({
+        .filter((file) => regex.test(file.file) || regex.test(file.displayName))
+        .map((file) => ({
         file,
-        index,
         bucket: getKnowledgeFileMatchBucket(file, patternTokens, caseSensitive),
     }))
-        .sort((left, right) => left.bucket - right.bucket || left.index - right.index)
+        .sort((left, right) => left.bucket - right.bucket || left.file.displayName.localeCompare(right.file.displayName))
         .map(({ file }) => file);
 }
 function getKnowledgeFileMatchBucket(file, patternTokens, caseSensitive) {