n8n 2.32.6 → 2.33.1

package/dist/modules/instance-ai/instance-ai-settings.service.js

@@ -10,26 +10,43 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var InstanceAiSettingsService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstanceAiSettingsService = void 0;
+exports.InstanceAiSettingsService = exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY = exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY = exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY = exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY = void 0;
+const node_util_1 = require("node:util");
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
+const permissions_1 = require("@n8n/permissions");
+const ensure_error_1 = require("@n8n/utils/errors/ensure-error");
 const n8n_workflow_1 = require("n8n-workflow");
 const credentials_finder_service_1 = require("../../credentials/credentials-finder.service");
 const credentials_service_1 = require("../../credentials/credentials.service");
+const instance_credential_broker_1 = require("../../credentials/instance-credential-broker");
+const conflict_error_1 = require("../../errors/response-errors/conflict.error");
+const forbidden_error_1 = require("../../errors/response-errors/forbidden.error");
 const unprocessable_error_1 = require("../../errors/response-errors/unprocessable.error");
 const event_service_1 = require("../../events/event.service");
 const ai_service_1 = require("../../services/ai.service");
 const user_service_1 = require("../../services/user.service");
 const sandbox_provider_1 = require("./sandbox-provider");
 const ADMIN_SETTINGS_KEY = 'instanceAi.settings';
+const N8N_SANDBOX_HEADER_NAME = 'x-api-key';
+const MODEL_PROVIDER_API_KEY_ENV = new Map([
+    ['anthropic', 'ANTHROPIC_API_KEY'],
+    ['cohere', 'COHERE_API_KEY'],
+    ['deepseek', 'DEEPSEEK_API_KEY'],
+    ['google', 'GOOGLE_GENERATIVE_AI_API_KEY'],
+    ['groq', 'GROQ_API_KEY'],
+    ['mistral', 'MISTRAL_API_KEY'],
+    ['openai', 'OPENAI_API_KEY'],
+    ['openrouter', 'OPENROUTER_API_KEY'],
+    ['xai', 'XAI_API_KEY'],
+]);
 const CREDENTIAL_TO_MODEL_PROVIDER = {
     openAiApi: 'openai',
     anthropicApi: 'anthropic',
     googlePalmApi: 'google',
-    ollamaApi: 'ollama',
     groqApi: 'groq',
     deepSeekApi: 'deepseek',
     mistralCloudApi: 'mistral',
@@ -37,33 +54,130 @@ const CREDENTIAL_TO_MODEL_PROVIDER = {
     openRouterApi: 'openrouter',
     cohereApi: 'cohere',
 };
-const SUPPORTED_CREDENTIAL_TYPES = Object.keys(CREDENTIAL_TO_MODEL_PROVIDER);
 const URL_FIELD_MAP = {
     openAiApi: 'url',
     anthropicApi: 'url',
     googlePalmApi: 'host',
-    ollamaApi: 'baseUrl',
 };
-const SANDBOX_CREDENTIAL_TYPES = ['daytonaApi', 'httpHeaderAuth'];
-const SEARCH_CREDENTIAL_TYPES = ['braveSearchApi', 'searXngApi'];
-const SERVICE_CREDENTIAL_TYPES = [...SANDBOX_CREDENTIAL_TYPES, ...SEARCH_CREDENTIAL_TYPES];
+function requireConnectionValue(type, data, field) {
+    const value = data[field];
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new unprocessable_error_1.UnprocessableRequestError(`The field "${field}" is required for provider connection type "${type}"`);
+    }
+    return value.trim();
+}
+function requireHttpUrl(type, data, field) {
+    const value = requireConnectionValue(type, data, field);
+    try {
+        const url = new URL(value);
+        if (url.protocol === 'http:' || url.protocol === 'https:')
+            return;
+    }
+    catch { }
+    throw new unprocessable_error_1.UnprocessableRequestError(`The field "${field}" must be a valid HTTP URL for provider connection type "${type}"`);
+}
+function validateModelCredential({ type, data, }) {
+    const apiKey = data.apiKey;
+    if (typeof apiKey === 'string' && apiKey.trim().length > 0)
+        return;
+    const urlField = URL_FIELD_MAP[type];
+    const url = urlField === undefined ? undefined : data[urlField];
+    if (typeof url === 'string' && url.trim().length > 0)
+        return;
+    throw new unprocessable_error_1.UnprocessableRequestError(urlField === undefined
+        ? `The field "apiKey" is required for provider connection type "${type}"`
+        : `The field "apiKey" or "${urlField}" is required for provider connection type "${type}"`);
+}
+function modelCredentialHeaders(credentialType, data) {
+    const headers = {};
+    if (credentialType === 'openAiApi' && typeof data.organizationId === 'string') {
+        const organizationId = data.organizationId.trim();
+        if (organizationId)
+            headers['OpenAI-Organization'] = organizationId;
+    }
+    if ((credentialType === 'openAiApi' || credentialType === 'anthropicApi') &&
+        data.header === true &&
+        typeof data.headerName === 'string' &&
+        typeof data.headerValue === 'string') {
+        const headerName = data.headerName.trim();
+        if (headerName)
+            headers[headerName] = data.headerValue;
+    }
+    return Object.keys(headers).length ? headers : undefined;
+}
+function validateSandboxServiceCredential({ type, data, }) {
+    const headerName = requireConnectionValue(type, data, 'name').toLowerCase();
+    if (headerName !== N8N_SANDBOX_HEADER_NAME) {
+        throw new unprocessable_error_1.UnprocessableRequestError(`The credential's header name must be "${N8N_SANDBOX_HEADER_NAME}" but is "${headerName}"`);
+    }
+    requireConnectionValue(type, data, 'value');
+}
+function validateDaytonaCredential({ type, data, }) {
+    requireHttpUrl(type, data, 'apiUrl');
+    requireConnectionValue(type, data, 'apiKey');
+}
+function validateSearchCredential({ type, data, }) {
+    if (type === 'searXngApi')
+        requireHttpUrl(type, data, 'apiUrl');
+    else
+        requireConnectionValue(type, data, 'apiKey');
+}
+exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY = {
+    id: 'instance-ai:model',
+    credentialTypes: api_types_1.INSTANCE_AI_MODEL_CREDENTIAL_TYPES,
+    validate: validateModelCredential,
+};
+exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY = {
+    id: 'instance-ai:sandbox:daytona',
+    credentialTypes: ['daytonaApi'],
+    validate: validateDaytonaCredential,
+};
+exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY = {
+    id: 'instance-ai:sandbox:n8n',
+    credentialTypes: ['httpHeaderAuth'],
+    validate: validateSandboxServiceCredential,
+};
+exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY = {
+    id: 'instance-ai:search',
+    credentialTypes: api_types_1.INSTANCE_AI_SEARCH_CREDENTIAL_TYPES,
+    validate: validateSearchCredential,
+};
+function validateInstanceAiCredential(policy, credential) {
+    if (policy === exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY) {
+        validateModelCredential(credential);
+    }
+    else if (policy === exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY) {
+        validateDaytonaCredential(credential);
+    }
+    else if (policy === exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY) {
+        validateSandboxServiceCredential(credential);
+    }
+    else if (policy === exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY) {
+        validateSearchCredential(credential);
+    }
+    else {
+        throw new n8n_workflow_1.UnexpectedError(`Unknown instance AI credential policy "${policy.id}"`);
+    }
+}
 let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSettingsService {
-    constructor(globalConfig, settingsRepository, userRepository, userService, aiService, credentialsService, credentialsFinderService, eventService) {
+    constructor(globalConfig, dbLockService, settingsRepository, userRepository, userService, aiService, credentialsService, credentialsFinderService, instanceCredentialBroker, eventService) {
+        this.dbLockService = dbLockService;
         this.settingsRepository = settingsRepository;
         this.userRepository = userRepository;
         this.userService = userService;
         this.aiService = aiService;
         this.credentialsService = credentialsService;
         this.credentialsFinderService = credentialsFinderService;
+        this.instanceCredentialBroker = instanceCredentialBroker;
         this.eventService = eventService;
         this.enabled = true;
         this.mcpAccessEnabled = true;
         this.permissions = { ...api_types_1.DEFAULT_INSTANCE_AI_PERMISSIONS };
-        this.adminDaytonaCredentialId = null;
-        this.adminN8nSandboxCredentialId = null;
-        this.adminSearchCredentialId = null;
+        this.adminModelName = null;
         this.config = globalConfig.instanceAi;
         this.deploymentConfig = globalConfig.deployment;
+        this.environmentSandboxProvider = (0, sandbox_provider_1.normalizeSandboxProvider)(this.config.sandboxProvider);
+        this.config.sandboxProvider = this.environmentSandboxProvider;
     }
     get isCloud() {
         return this.deploymentConfig.type === 'cloud';
@@ -77,13 +191,7 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
             sandboxEnabled: this.config.sandboxEnabled,
             sandboxProvider: this.config.sandboxProvider,
         };
-        const row = await this.settingsRepository.findByKey(ADMIN_SETTINGS_KEY);
-        if (row) {
-            const persisted = (0, n8n_workflow_1.jsonParse)(row.value, {
-                fallbackValue: {},
-            });
-            this.applyAdminSettings(persisted);
-        }
+        await this.reloadFromDb();
         const c = this.config;
         const overridden = c.sandboxEnabled !== envSnapshot.sandboxEnabled ||
             c.sandboxProvider !== envSnapshot.sandboxProvider;
@@ -97,62 +205,334 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
             logger.warn(`Sandbox unavailable: ${sandboxStatus.unavailableReason}`);
         }
     }
-    getAdminSettings() {
+    async getAdminSettings() {
+        const isManaged = this.isCloud || this.aiService.isProxyEnabled();
+        if (isManaged) {
+            return this.buildAdminSettingsResponse({
+                modelCredentialId: null,
+                modelName: null,
+                daytonaCredentialId: null,
+                n8nSandboxCredentialId: null,
+                searchCredentialId: null,
+            });
+        }
+        const [modelSelection, daytonaCredentialId, n8nSandboxCredentialId, searchCredentialId] = await Promise.all([
+            this.readAdminModelSelection(),
+            this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY),
+            this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY),
+            this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY),
+        ]);
+        return this.buildAdminSettingsResponse({
+            ...modelSelection,
+            daytonaCredentialId,
+            n8nSandboxCredentialId,
+            searchCredentialId,
+        });
+    }
+    buildAdminSettingsResponse(credentialSelection) {
         const c = this.config;
+        const modelProviderApiKeyEnv = MODEL_PROVIDER_API_KEY_ENV.get(c.model.split('/', 1)[0] ?? '');
+        const isManaged = this.isCloud || this.aiService.isProxyEnabled();
         return {
             enabled: this.enabled,
             permissions: { ...this.permissions },
-            mcpServers: c.mcpServers,
             mcpAccessEnabled: this.mcpAccessEnabled,
             sandboxEnabled: c.sandboxEnabled,
-            sandboxProvider: (0, sandbox_provider_1.normalizeSandboxProvider)(c.sandboxProvider),
-            sandboxImage: c.sandboxImage,
-            sandboxTimeout: c.sandboxTimeout,
-            daytonaCredentialId: this.adminDaytonaCredentialId,
-            n8nSandboxCredentialId: this.adminN8nSandboxCredentialId,
-            searchCredentialId: this.adminSearchCredentialId,
+            sandboxProvider: this.aiService.isProxyEnabled()
+                ? 'daytona'
+                : (0, sandbox_provider_1.normalizeSandboxProvider)(c.sandboxProvider),
+            daytonaCredentialId: isManaged ? null : credentialSelection.daytonaCredentialId,
+            n8nSandboxCredentialId: isManaged ? null : credentialSelection.n8nSandboxCredentialId,
+            searchCredentialId: isManaged ? null : credentialSelection.searchCredentialId,
+            modelCredentialId: isManaged ? null : credentialSelection.modelCredentialId,
+            modelName: isManaged ? null : credentialSelection.modelName,
+            modelEnvConfigured: Boolean(c.modelApiKey.trim() ||
+                c.modelUrl.trim() ||
+                (modelProviderApiKeyEnv && process.env[modelProviderApiKeyEnv]?.trim())),
+            sandboxEnvConfigured: this.environmentSandboxProvider === 'daytona'
+                ? Boolean(c.daytonaApiKey.trim())
+                : Boolean(c.n8nSandboxServiceUrl.trim()),
+            searchEnvConfigured: Boolean(c.braveSearchApiKey.trim() || c.searxngUrl.trim()),
             localGatewayDisabled: this.isLocalGatewayDisabled(),
             browserUseEnabled: this.isBrowserUseEnabled(),
         };
     }
-    async updateAdminSettings(update) {
+    async updateAdminSettings(update, user) {
         this.rejectManagedFields(update, InstanceAiSettingsService_1.MANAGED_ADMIN_FIELDS, this.deploymentLabel());
-        this.validateAdminSettingsUpdate(update);
-        const c = this.config;
-        const previousMcpServers = c.mcpServers;
-        const previousMcpAccessEnabled = this.mcpAccessEnabled;
-        if (update.enabled !== undefined)
-            this.enabled = update.enabled;
-        if (update.permissions) {
-            this.permissions = { ...this.permissions, ...update.permissions };
-        }
-        if (update.mcpServers !== undefined)
-            c.mcpServers = update.mcpServers;
-        if (update.mcpAccessEnabled !== undefined)
-            this.mcpAccessEnabled = update.mcpAccessEnabled;
-        if (update.sandboxEnabled !== undefined)
-            c.sandboxEnabled = update.sandboxEnabled;
-        if (update.sandboxProvider !== undefined)
-            c.sandboxProvider = update.sandboxProvider;
-        if (update.sandboxImage !== undefined)
-            c.sandboxImage = update.sandboxImage;
-        if (update.sandboxTimeout !== undefined)
-            c.sandboxTimeout = update.sandboxTimeout;
-        if (update.daytonaCredentialId !== undefined)
-            this.adminDaytonaCredentialId = update.daytonaCredentialId;
-        if (update.n8nSandboxCredentialId !== undefined)
-            this.adminN8nSandboxCredentialId = update.n8nSandboxCredentialId;
-        if (update.searchCredentialId !== undefined)
-            this.adminSearchCredentialId = update.searchCredentialId;
-        if (update.localGatewayDisabled !== undefined)
-            c.localGatewayDisabled = update.localGatewayDisabled;
-        if (update.browserUseEnabled !== undefined)
-            c.browserUseEnabled = update.browserUseEnabled;
-        await this.persistAdminSettings();
-        this.eventService.emit('instance-ai-settings-updated', {
-            mcpSettingsChanged: c.mcpServers !== previousMcpServers || this.mcpAccessEnabled !== previousMcpAccessEnabled,
+        if (this.isCloud || this.aiService.isProxyEnabled()) {
+            this.rejectManagedFields(update, InstanceAiSettingsService_1.INSTANCE_CREDENTIAL_FIELDS, this.deploymentLabel());
+            this.rejectManagedFields(update, ['modelName', 'sandboxProvider'], this.deploymentLabel());
+        }
+        const { modelCredentialId: initialModelCredentialId, daytonaCredentialId: initialDaytonaCredentialId, n8nSandboxCredentialId: initialN8nSandboxCredentialId, searchCredentialId: initialSearchCredentialId, modelConnection, sandboxConnection, searchConnection, ...settingsUpdate } = update;
+        let modelCredentialId = initialModelCredentialId;
+        let daytonaCredentialId = initialDaytonaCredentialId;
+        let n8nSandboxCredentialId = initialN8nSandboxCredentialId;
+        let searchCredentialId = initialSearchCredentialId;
+        this.rejectConnectionConflicts(update);
+        if (modelConnection !== undefined ||
+            sandboxConnection !== undefined ||
+            searchConnection !== undefined) {
+            if (!user || !(0, permissions_1.hasGlobalScope)(user, 'credential:manageInstance')) {
+                throw new forbidden_error_1.ForbiddenError('You do not have permission to manage provider connections');
+            }
+        }
+        if (modelConnection) {
+            const modelName = settingsUpdate.modelName === undefined
+                ? (await this.readAdminModelSelection()).modelName
+                : settingsUpdate.modelName;
+            if (modelName === null) {
+                throw new unprocessable_error_1.UnprocessableRequestError('modelName must be set together with modelCredentialId');
+            }
+        }
+        const [modelPrepared, searchPrepared, sandboxPrepared] = user
+            ? await Promise.all([
+                this.prepareConnection(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, 'AI Assistant model', modelConnection),
+                this.prepareConnection(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, 'AI Assistant web search', searchConnection),
+                this.prepareSandboxConnection(sandboxConnection),
+            ])
+            : [undefined, undefined, undefined];
+        this.validateAdminSettingsUpdate(update, this.snapshotAdminSettings(), sandboxConnection === null
+            ? this.environmentSandboxProvider
+            : sandboxConnection?.type === 'daytonaApi'
+                ? 'daytona'
+                : sandboxConnection?.type === 'httpHeaderAuth'
+                    ? 'n8n-sandbox'
+                    : settingsUpdate.sandboxProvider);
+        await this.runConnectionHooks([modelPrepared, searchPrepared, sandboxPrepared]);
+        const { previous, next, credentialSelection } = await this.dbLockService.withLockContext(1007, async (ctx) => {
+            if (user && modelConnection !== undefined) {
+                modelCredentialId = await this.upsertConnection(user, exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, 'AI Assistant model', modelConnection, ctx, modelPrepared);
+            }
+            if (user && searchConnection !== undefined) {
+                searchCredentialId = await this.upsertConnection(user, exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, 'AI Assistant web search', searchConnection, ctx, searchPrepared);
+            }
+            if (user && sandboxConnection !== undefined) {
+                const sandbox = await this.upsertSandboxConnection(user, sandboxConnection, ctx, sandboxPrepared);
+                daytonaCredentialId = sandbox.daytonaCredentialId;
+                n8nSandboxCredentialId = sandbox.n8nSandboxCredentialId;
+                if (sandbox.sandboxProvider)
+                    settingsUpdate.sandboxProvider = sandbox.sandboxProvider;
+            }
+            const updateCredentialAssignment = async (credentialUse, credentialId) => {
+                if (credentialId === undefined)
+                    return;
+                if (credentialId === null) {
+                    await this.instanceCredentialBroker.clearForUse(credentialUse, ctx);
+                }
+                else {
+                    await this.instanceCredentialBroker.assignForUse(credentialUse, credentialId, ctx);
+                }
+            };
+            const persisted = await this.settingsRepository.findByKeyInContext(ADMIN_SETTINGS_KEY, ctx);
+            const current = this.mergeAdminSettings(this.snapshotAdminSettings(), this.parsePersistedAdminSettings(persisted?.value));
+            const [currentModelCredentialId, currentDaytonaCredentialId, currentN8nCredentialId, currentSearchCredentialId,] = await Promise.all([
+                this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, ctx),
+                this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, ctx),
+                this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, ctx),
+                this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, ctx),
+            ]);
+            const nextDaytonaCredentialId = daytonaCredentialId === undefined ? currentDaytonaCredentialId : daytonaCredentialId;
+            const nextN8nCredentialId = n8nSandboxCredentialId === undefined ? currentN8nCredentialId : n8nSandboxCredentialId;
+            const nextSearchCredentialId = searchCredentialId === undefined ? currentSearchCredentialId : searchCredentialId;
+            const clearsSandboxConnection = (sandboxConnection !== undefined ||
+                daytonaCredentialId !== undefined ||
+                n8nSandboxCredentialId !== undefined) &&
+                nextDaytonaCredentialId === null &&
+                nextN8nCredentialId === null;
+            this.validateAdminSettingsUpdate(update, current, clearsSandboxConnection
+                ? this.environmentSandboxProvider
+                : settingsUpdate.sandboxProvider);
+            const previous = this.snapshotAdminSettings();
+            const next = this.mergeAdminSettings(current, settingsUpdate);
+            if (clearsSandboxConnection)
+                delete next.sandboxProvider;
+            const nextModelCredentialId = modelCredentialId === undefined ? currentModelCredentialId : modelCredentialId;
+            const nextModelName = settingsUpdate.modelName !== undefined
+                ? settingsUpdate.modelName
+                : modelCredentialId === null
+                    ? null
+                    : current.modelName;
+            if (modelCredentialId !== undefined || settingsUpdate.modelName !== undefined) {
+                const hasCredential = nextModelCredentialId !== null && nextModelCredentialId !== undefined;
+                const hasModelName = nextModelName !== null && nextModelName !== undefined;
+                if (hasCredential && !hasModelName) {
+                    throw new unprocessable_error_1.UnprocessableRequestError('modelName must be set together with modelCredentialId');
+                }
+                if (hasModelName && !hasCredential) {
+                    throw new unprocessable_error_1.UnprocessableRequestError('modelName requires modelCredentialId');
+                }
+            }
+            next.modelName = nextModelName ?? null;
+            await updateCredentialAssignment(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, modelCredentialId);
+            await updateCredentialAssignment(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, daytonaCredentialId);
+            await updateCredentialAssignment(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, n8nSandboxCredentialId);
+            await updateCredentialAssignment(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, searchCredentialId);
+            if (typeof modelCredentialId === 'string') {
+                await this.validateAssignedServiceCredential(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, ctx);
+            }
+            if (typeof daytonaCredentialId === 'string') {
+                await this.validateAssignedServiceCredential(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, ctx);
+            }
+            if (typeof n8nSandboxCredentialId === 'string') {
+                await this.validateAssignedServiceCredential(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, ctx);
+            }
+            if (typeof searchCredentialId === 'string') {
+                await this.validateAssignedServiceCredential(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, ctx);
+            }
+            await this.settingsRepository.upsertByKey(ADMIN_SETTINGS_KEY, JSON.stringify(next), true, ctx);
+            return {
+                previous,
+                next,
+                credentialSelection: {
+                    modelCredentialId: nextModelCredentialId ?? null,
+                    modelName: next.modelName ?? null,
+                    daytonaCredentialId: nextDaytonaCredentialId,
+                    n8nSandboxCredentialId: nextN8nCredentialId,
+                    searchCredentialId: nextSearchCredentialId,
+                },
+            };
         });
-        return this.getAdminSettings();
+        this.applyAdminSettings(next);
+        this.emitSettingsUpdated(previous, next);
+        return this.buildAdminSettingsResponse(credentialSelection);
+    }
+    rejectConnectionConflicts(update) {
+        const conflicts = [
+            ['modelConnection', 'modelCredentialId', update.modelCredentialId !== undefined],
+            ['sandboxConnection', 'daytonaCredentialId', update.daytonaCredentialId !== undefined],
+            ['sandboxConnection', 'n8nSandboxCredentialId', update.n8nSandboxCredentialId !== undefined],
+            ['searchConnection', 'searchCredentialId', update.searchCredentialId !== undefined],
+        ];
+        for (const [connectionField, idField, idPresent] of conflicts) {
+            const connectionPresent = update[connectionField] !== undefined;
+            if (connectionPresent && idPresent) {
+                throw new unprocessable_error_1.UnprocessableRequestError(`Cannot combine ${connectionField} with ${idField} in one update`);
+            }
+        }
+    }
+    async upsertConnection(user, policy, name, connection, ctx, prepared) {
+        if (connection === null)
+            return null;
+        if (!prepared?.encryptedData) {
+            throw new n8n_workflow_1.UnexpectedError('Prepared provider connection is missing encrypted data');
+        }
+        let current;
+        try {
+            current = await this.instanceCredentialBroker.resolveForUse(policy, ctx);
+        }
+        catch (error) {
+            if (!(error instanceof unprocessable_error_1.UnprocessableRequestError))
+                throw error;
+            current = null;
+        }
+        if ((current?.id ?? null) !== prepared.expectedCredentialId ||
+            current?.name !== prepared.expectedCredentialName ||
+            current?.type !== prepared.expectedCredentialType ||
+            (current !== null &&
+                current !== undefined &&
+                !(0, node_util_1.isDeepStrictEqual)(current.data, prepared.expectedCredentialData))) {
+            throw new conflict_error_1.ConflictError('Provider connection changed; retry');
+        }
+        const data = connection.data;
+        if (current && current.type === connection.type) {
+            await this.credentialsService.updateInstanceCredential(user, current.id, { name: current.name, type: current.type, data }, ctx, { skipExternalHooks: true, encryptedData: prepared.encryptedData });
+            return current.id;
+        }
+        const dto = {
+            name,
+            type: connection.type,
+            data: connection.data,
+            usageScope: 'instance',
+        };
+        const created = await this.credentialsService.createInstanceCredential(dto, user, ctx, {
+            skipExternalHooks: true,
+            encryptedData: prepared.encryptedData,
+        });
+        return created.id;
+    }
+    async prepareConnection(policy, name, connection) {
+        if (!connection)
+            return undefined;
+        if (!policy.credentialTypes.includes(connection.type)) {
+            throw new unprocessable_error_1.UnprocessableRequestError(`Connection type "${connection.type}" is not supported for "${policy.id}"`);
+        }
+        let current;
+        try {
+            current = await this.instanceCredentialBroker.resolveForUse(policy);
+        }
+        catch (error) {
+            if (!(error instanceof unprocessable_error_1.UnprocessableRequestError))
+                throw error;
+            current = null;
+        }
+        const data = current?.type === connection.type
+            ? this.credentialsService.unredact(connection.data, current.data, this.credentialsService.getCredentialTypeProperties(connection.type))
+            : connection.data;
+        validateInstanceAiCredential(policy, { type: connection.type, data });
+        const existing = current?.type === connection.type ? { id: current.id, name: current.name } : null;
+        return {
+            event: existing ? 'update' : 'create',
+            expectedCredentialId: current?.id ?? null,
+            expectedCredentialName: current?.name,
+            expectedCredentialType: current?.type,
+            expectedCredentialData: current?.data,
+            credential: {
+                id: existing?.id ?? null,
+                name: existing?.name ?? name,
+                type: connection.type,
+                data,
+            },
+        };
+    }
+    async prepareSandboxConnection(connection) {
+        if (!connection)
+            return undefined;
+        const policy = connection.type === 'daytonaApi'
+            ? exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY
+            : connection.type === 'httpHeaderAuth'
+                ? exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY
+                : undefined;
+        if (!policy) {
+            throw new unprocessable_error_1.UnprocessableRequestError(`Connection type "${connection.type}" is not supported for the sandbox`);
+        }
+        return await this.prepareConnection(policy, 'AI Assistant sandbox', connection);
+    }
+    async runConnectionHooks(preparedConnections) {
+        for (const prepared of preparedConnections) {
+            if (prepared) {
+                prepared.encryptedData = await this.credentialsService.runInstanceCredentialHooks(prepared.event, prepared.credential);
+            }
+        }
+    }
+    async upsertSandboxConnection(user, connection, ctx, prepared) {
+        const name = 'AI Assistant sandbox';
+        if (connection === null) {
+            return {
+                daytonaCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, name, null, ctx),
+                n8nSandboxCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, name, null, ctx),
+            };
+        }
+        if (connection.type === 'daytonaApi') {
+            return {
+                daytonaCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, name, connection, ctx, prepared),
+                n8nSandboxCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, name, null, ctx),
+                sandboxProvider: 'daytona',
+            };
+        }
+        if (connection.type === 'httpHeaderAuth') {
+            return {
+                n8nSandboxCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, name, connection, ctx, prepared),
+                daytonaCredentialId: await this.upsertConnection(user, exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, name, null, ctx),
+                sandboxProvider: 'n8n-sandbox',
+            };
+        }
+        throw new unprocessable_error_1.UnprocessableRequestError(`Connection type "${connection.type}" is not supported for the sandbox`);
+    }
+    async reloadFromDb() {
+        const previous = this.snapshotAdminSettings();
+        const persisted = await this.readPersistedAdminSettings();
+        this.applyAdminSettings(persisted);
+        this.emitSettingsUpdated(previous, this.snapshotAdminSettings());
     }
     async getUserPreferences(user) {
         const prefs = this.readUserPreferences(user);
@@ -189,100 +569,113 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
         user.settings = { ...(user.settings ?? {}), instanceAi: prefs };
         return await this.getUserPreferences(user);
     }
-    async listModelCredentials(user) {
-        if (this.aiService.isProxyEnabled())
+    async listInstanceModelCredentials() {
+        if (this.isCloud || this.aiService.isProxyEnabled())
             return [];
-        const allCredentials = await this.credentialsFinderService.findCredentialsForUser(user, [
-            'credential:read',
-        ]);
-        return allCredentials
-            .filter((c) => SUPPORTED_CREDENTIAL_TYPES.includes(c.type))
-            .map((c) => ({
+        const instanceCredentials = await this.instanceCredentialBroker.listForUse(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY);
+        return instanceCredentials.map((c) => ({
             id: c.id,
             name: c.name,
             type: c.type,
-            provider: CREDENTIAL_TO_MODEL_PROVIDER[c.type] ?? 'custom',
         }));
     }
-    async listServiceCredentials(user) {
-        if (this.aiService.isProxyEnabled())
+    async listInstanceServiceCredentials() {
+        if (this.isCloud || this.aiService.isProxyEnabled())
             return [];
-        const allCredentials = await this.credentialsFinderService.findCredentialsForUser(user, [
-            'credential:read',
+        const credentials = await Promise.all([
+            this.instanceCredentialBroker.listForUse(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY),
+            this.instanceCredentialBroker.listForUse(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY),
+            this.instanceCredentialBroker.listForUse(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY),
         ]);
-        return allCredentials
-            .filter((c) => SERVICE_CREDENTIAL_TYPES.includes(c.type))
-            .map((c) => ({
+        return credentials.flat().map((c) => ({
             id: c.id,
             name: c.name,
             type: c.type,
-            provider: c.type,
         }));
     }
-    async resolveDaytonaConfig(user) {
-        const credentialId = this.adminDaytonaCredentialId;
-        if (!credentialId) {
-            const { daytonaApiUrl, daytonaApiKey } = this.config;
-            return {
-                apiUrl: daytonaApiUrl || undefined,
-                apiKey: daytonaApiKey || undefined,
-            };
-        }
-        const credential = await this.credentialsFinderService.findCredentialForUser(credentialId, user, ['credential:read']);
-        if (!credential) {
-            return {};
-        }
-        const data = await this.credentialsService.decrypt(credential, true);
-        return {
-            apiUrl: typeof data.apiUrl === 'string' ? data.apiUrl : undefined,
-            apiKey: typeof data.apiKey === 'string' ? data.apiKey : undefined,
+    async resolveDaytonaConfig() {
+        const { daytonaApiUrl, daytonaApiKey } = this.config;
+        const envConfig = {
+            apiUrl: daytonaApiUrl || undefined,
+            apiKey: daytonaApiKey || undefined,
         };
+        const resolved = await this.resolveServiceCredential(exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY, 'Daytona sandbox');
+        if (!resolved)
+            return envConfig;
+        const { data } = resolved;
+        const apiUrl = typeof data.apiUrl === 'string' ? data.apiUrl : undefined;
+        const apiKey = typeof data.apiKey === 'string' ? data.apiKey : undefined;
+        if (!apiUrl || !apiKey) {
+            this.warnCredentialFallback('Daytona sandbox', exports.INSTANCE_AI_DAYTONA_CREDENTIAL_POLICY.id, 'Credential data is incomplete');
+            return envConfig;
+        }
+        return { apiUrl, apiKey };
     }
-    async resolveN8nSandboxConfig(user) {
+    async resolveN8nSandboxConfig() {
         const { n8nSandboxServiceUrl, n8nSandboxServiceApiKey } = this.config;
-        const credentialId = this.adminN8nSandboxCredentialId;
-        if (!credentialId) {
-            return {
-                serviceUrl: n8nSandboxServiceUrl || undefined,
-                apiKey: n8nSandboxServiceApiKey || undefined,
-            };
-        }
-        const credential = await this.credentialsFinderService.findCredentialForUser(credentialId, user, ['credential:read']);
-        if (!credential) {
-            return {
-                serviceUrl: n8nSandboxServiceUrl || undefined,
-                apiKey: n8nSandboxServiceApiKey || undefined,
-            };
-        }
-        const data = await this.credentialsService.decrypt(credential, true);
-        const headerName = typeof data.name === 'string' ? data.name.trim().toLowerCase() : '';
-        const apiKey = typeof data.value === 'string' ? data.value : undefined;
-        return {
+        const envConfig = {
             serviceUrl: n8nSandboxServiceUrl || undefined,
-            apiKey: headerName === 'x-api-key' ? apiKey : n8nSandboxServiceApiKey || undefined,
+            apiKey: n8nSandboxServiceApiKey || undefined,
         };
-    }
-    async resolveSearchConfig(user) {
-        const credentialId = this.adminSearchCredentialId;
-        if (!credentialId) {
-            const { braveSearchApiKey, searxngUrl } = this.config;
-            return {
-                braveApiKey: braveSearchApiKey || undefined,
-                searxngUrl: searxngUrl || undefined,
-            };
+        const resolved = await this.resolveServiceCredential(exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY, 'n8n Sandbox');
+        if (!resolved)
+            return envConfig;
+        const { data } = resolved;
+        const headerName = typeof data.name === 'string' ? data.name.trim().toLowerCase() : '';
+        const apiKey = typeof data.value === 'string' ? data.value : undefined;
+        if (headerName !== N8N_SANDBOX_HEADER_NAME) {
+            this.warnCredentialFallback('n8n Sandbox', exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY.id, `Credential header must be "${N8N_SANDBOX_HEADER_NAME}" but is "${headerName || '(empty)'}"`);
+            return envConfig;
         }
-        const credential = await this.credentialsFinderService.findCredentialForUser(credentialId, user, ['credential:read']);
-        if (!credential) {
-            return {};
+        if (!apiKey) {
+            this.warnCredentialFallback('n8n Sandbox', exports.INSTANCE_AI_N8N_SANDBOX_CREDENTIAL_POLICY.id, 'Credential data is incomplete');
+            return envConfig;
         }
-        const data = await this.credentialsService.decrypt(credential, true);
-        if (credential.type === 'braveSearchApi') {
-            return { braveApiKey: typeof data.apiKey === 'string' ? data.apiKey : undefined };
+        return { serviceUrl: n8nSandboxServiceUrl || undefined, apiKey };
+    }
+    async resolveSearchConfig() {
+        const { braveSearchApiKey, searxngUrl } = this.config;
+        const envConfig = {
+            braveApiKey: braveSearchApiKey || undefined,
+            searxngUrl: searxngUrl || undefined,
+        };
+        const resolved = await this.resolveServiceCredential(exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY, 'search');
+        if (!resolved)
+            return envConfig;
+        const { type, data } = resolved;
+        if (type === 'braveSearchApi' && typeof data.apiKey === 'string' && data.apiKey) {
+            return { braveApiKey: data.apiKey };
         }
-        if (credential.type === 'searXngApi') {
-            return { searxngUrl: typeof data.apiUrl === 'string' ? data.apiUrl : undefined };
+        if (type === 'searXngApi' && typeof data.apiUrl === 'string' && data.apiUrl) {
+            return { searxngUrl: data.apiUrl };
         }
-        return {};
+        this.warnCredentialFallback('search', exports.INSTANCE_AI_SEARCH_CREDENTIAL_POLICY.id, 'Credential data is incomplete');
+        return envConfig;
+    }
+    async validateAssignedServiceCredential(policy, ctx) {
+        const resolved = await this.instanceCredentialBroker.resolveForUse(policy, ctx);
+        if (!resolved)
+            return;
+        validateInstanceAiCredential(policy, { type: resolved.type, data: resolved.data });
+    }
+    async resolveServiceCredential(policy, service, ctx) {
+        if (this.isCloud || this.aiService.isProxyEnabled())
+            return null;
+        const resolved = ctx
+            ? this.instanceCredentialBroker.resolveForUse(policy, ctx)
+            : this.instanceCredentialBroker.resolveForUse(policy);
+        return await resolved.catch((error) => {
+            this.warnCredentialFallback(service, policy.id, (0, ensure_error_1.ensureError)(error).message);
+            return null;
+        });
+    }
+    warnCredentialFallback(service, credentialUseId, reason) {
+        di_1.Container.get(backend_common_1.Logger)
+            .scoped('instance-ai')
+            .warn(`Could not resolve the configured ${service} credential; using environment fallback`, {
+            credentialUseId,
+            error: reason,
+        });
     }
     getPermissions() {
         return { ...this.permissions };
@@ -310,7 +703,9 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
         return this.config.browserUseEnabled;
     }
     getSandboxStatus() {
-        const provider = (0, sandbox_provider_1.normalizeSandboxProvider)(this.config.sandboxProvider);
+        const provider = this.aiService.isProxyEnabled()
+            ? 'daytona'
+            : (0, sandbox_provider_1.normalizeSandboxProvider)(this.config.sandboxProvider);
         const unavailableReason = this.getSandboxUnavailableReason(this.config.sandboxEnabled, provider);
         return {
             enabled: this.config.sandboxEnabled,
@@ -324,10 +719,16 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
     }
     resolveModelName(user) {
         const prefs = this.readUserPreferences(user);
-        return prefs.modelName ?? this.extractModelName(this.config.model);
+        const adminModelName = this.isCloud || this.aiService.isProxyEnabled() ? null : this.adminModelName;
+        return adminModelName ?? prefs.modelName ?? this.extractModelName(this.config.model);
     }
     async resolveModelConfig(user) {
         const prefs = this.readUserPreferences(user);
+        const fallbackModelName = prefs.modelName ?? this.extractModelName(this.config.model);
+        const adminModelConfig = await this.resolveAdminModelConfig();
+        if (adminModelConfig) {
+            return adminModelConfig;
+        }
         const credentialId = prefs.credentialId ?? null;
         if (!credentialId) {
             return this.envVarModelConfig();
@@ -336,24 +737,44 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
         if (!credential) {
             return this.envVarModelConfig();
         }
-        const provider = CREDENTIAL_TO_MODEL_PROVIDER[credential.type];
+        return ((await this.buildModelConfigFromCredential(credential, fallbackModelName)) ??
+            this.envVarModelConfig());
+    }
+    async resolveAdminModelConfig() {
+        if (this.isCloud || this.aiService.isProxyEnabled())
+            return null;
+        return await this.withPersistedAdminSettings(async (ctx, persisted) => {
+            const modelName = persisted.modelName ?? null;
+            if (!modelName)
+                return null;
+            const resolved = await this.resolveServiceCredential(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, 'model', ctx);
+            if (!resolved)
+                return null;
+            const config = this.buildModelConfig(resolved.type, resolved.data, modelName);
+            if (!config) {
+                this.warnCredentialFallback('model', exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY.id, 'Credential data is incomplete');
+            }
+            return config;
+        });
+    }
+    async buildModelConfigFromCredential(credential, modelName) {
+        const data = await this.credentialsService.decrypt(credential, true);
+        return this.buildModelConfig(credential.type, data, modelName);
+    }
+    buildModelConfig(credentialType, data, modelName) {
+        const provider = CREDENTIAL_TO_MODEL_PROVIDER[credentialType];
         if (!provider) {
-            return this.envVarModelConfig();
+            return null;
         }
-        const data = await this.credentialsService.decrypt(credential, true);
         const apiKey = typeof data.apiKey === 'string' ? data.apiKey : '';
-        const urlField = URL_FIELD_MAP[credential.type];
+        const urlField = URL_FIELD_MAP[credentialType];
         const rawUrl = urlField ? data[urlField] : undefined;
         const baseUrl = typeof rawUrl === 'string' ? rawUrl : '';
-        const modelName = prefs.modelName ?? this.extractModelName(this.config.model);
         const id = `${provider}/${modelName}`;
-        if (baseUrl) {
-            return { id, url: baseUrl, ...(apiKey ? { apiKey } : {}) };
-        }
-        if (apiKey) {
-            return { id, url: '', apiKey };
-        }
-        return id;
+        if (!baseUrl && !apiKey)
+            return null;
+        const headers = modelCredentialHeaders(credentialType, data);
+        return { id, url: baseUrl, ...(apiKey ? { apiKey } : {}), ...(headers ? { headers } : {}) };
     }
     deploymentLabel() {
         if (this.isCloud)
@@ -369,23 +790,24 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
             throw new unprocessable_error_1.UnprocessableRequestError(`Cannot update ${label}-managed fields: ${present.join(', ')}`);
         }
     }
-    validateAdminSettingsUpdate(update) {
-        const c = this.config;
+    validateAdminSettingsUpdate(update, current, sandboxProviderOverride) {
         const touchesSandboxSettings = update.sandboxEnabled !== undefined ||
             update.sandboxProvider !== undefined ||
             update.sandboxImage !== undefined ||
             update.sandboxTimeout !== undefined ||
             update.daytonaCredentialId !== undefined ||
-            update.n8nSandboxCredentialId !== undefined;
-        if (!touchesSandboxSettings) {
+            update.n8nSandboxCredentialId !== undefined ||
+            update.sandboxConnection !== undefined;
+        if (!touchesSandboxSettings)
             return;
-        }
-        const sandboxProvider = update.sandboxProvider ?? (0, sandbox_provider_1.normalizeSandboxProvider)(c.sandboxProvider);
-        const sandboxEnabled = update.sandboxEnabled ?? c.sandboxEnabled;
+        const sandboxProvider = (0, sandbox_provider_1.normalizeSandboxProvider)(sandboxProviderOverride ??
+            update.sandboxProvider ??
+            current.sandboxProvider ??
+            this.environmentSandboxProvider);
+        const sandboxEnabled = update.sandboxEnabled ?? current.sandboxEnabled ?? false;
         const unavailableReason = this.getSandboxUnavailableReason(sandboxEnabled, sandboxProvider);
-        if (unavailableReason) {
+        if (unavailableReason)
             throw new unprocessable_error_1.UnprocessableRequestError(unavailableReason);
-        }
     }
     getSandboxUnavailableReason(sandboxEnabled, sandboxProvider) {
         if (sandboxEnabled &&
@@ -431,18 +853,20 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
             this.mcpAccessEnabled = persisted.mcpAccessEnabled;
         if (persisted.sandboxEnabled !== undefined)
             c.sandboxEnabled = persisted.sandboxEnabled;
-        if (persisted.sandboxProvider !== undefined)
-            c.sandboxProvider = (0, sandbox_provider_1.normalizeSandboxProvider)(persisted.sandboxProvider);
+        const isProxyEnabled = this.aiService.isProxyEnabled();
+        this.sandboxProviderOverride =
+            this.isCloud || isProxyEnabled || !persisted.sandboxProvider
+                ? undefined
+                : (0, sandbox_provider_1.normalizeSandboxProvider)(persisted.sandboxProvider);
+        c.sandboxProvider = isProxyEnabled
+            ? 'daytona'
+            : (this.sandboxProviderOverride ?? this.environmentSandboxProvider);
         if (persisted.sandboxImage !== undefined)
             c.sandboxImage = persisted.sandboxImage;
         if (persisted.sandboxTimeout !== undefined)
             c.sandboxTimeout = persisted.sandboxTimeout;
-        if (persisted.daytonaCredentialId !== undefined)
-            this.adminDaytonaCredentialId = persisted.daytonaCredentialId;
-        if (persisted.n8nSandboxCredentialId !== undefined)
-            this.adminN8nSandboxCredentialId = persisted.n8nSandboxCredentialId;
-        if (persisted.searchCredentialId !== undefined)
-            this.adminSearchCredentialId = persisted.searchCredentialId;
+        if (persisted.modelName !== undefined)
+            this.adminModelName = persisted.modelName;
         if (persisted.localGatewayDisabled !== undefined)
             c.localGatewayDisabled = persisted.localGatewayDisabled;
         if (persisted.browserUseEnabled !== undefined)
@@ -451,36 +875,88 @@ let InstanceAiSettingsService = InstanceAiSettingsService_1 = class InstanceAiSe
     readUserPreferences(user) {
         return user.settings?.instanceAi ?? {};
     }
-    async persistAdminSettings() {
+    snapshotAdminSettings() {
         const c = this.config;
-        const value = {
+        return {
             enabled: this.enabled,
             permissions: this.permissions,
             mcpServers: c.mcpServers,
             mcpAccessEnabled: this.mcpAccessEnabled,
             sandboxEnabled: c.sandboxEnabled,
-            sandboxProvider: c.sandboxProvider,
+            ...(this.sandboxProviderOverride ? { sandboxProvider: this.sandboxProviderOverride } : {}),
             sandboxImage: c.sandboxImage,
             sandboxTimeout: c.sandboxTimeout,
-            daytonaCredentialId: this.adminDaytonaCredentialId,
-            n8nSandboxCredentialId: this.adminN8nSandboxCredentialId,
-            searchCredentialId: this.adminSearchCredentialId,
+            modelName: this.adminModelName,
             localGatewayDisabled: c.localGatewayDisabled,
             browserUseEnabled: c.browserUseEnabled,
         };
-        await this.settingsRepository.upsert({ key: ADMIN_SETTINGS_KEY, value: JSON.stringify(value), loadOnStartup: true }, ['key']);
+    }
+    mergeAdminSettings(base, update) {
+        return {
+            ...base,
+            ...update,
+            permissions: update.permissions
+                ? { ...(base.permissions ?? api_types_1.DEFAULT_INSTANCE_AI_PERMISSIONS), ...update.permissions }
+                : base.permissions,
+        };
+    }
+    async readPersistedAdminSettings() {
+        const row = await this.settingsRepository.findByKey(ADMIN_SETTINGS_KEY);
+        return this.parsePersistedAdminSettings(row?.value);
+    }
+    async withPersistedAdminSettings(read) {
+        return await this.dbLockService.withLockContext(1007, async (ctx) => {
+            const row = await this.settingsRepository.findByKeyInContext(ADMIN_SETTINGS_KEY, ctx);
+            return await read(ctx, this.parsePersistedAdminSettings(row?.value));
+        });
+    }
+    async readAdminModelSelection() {
+        return await this.withPersistedAdminSettings(async (ctx, persisted) => ({
+            modelCredentialId: await this.instanceCredentialBroker.getAssignedCredentialId(exports.INSTANCE_AI_MODEL_CREDENTIAL_POLICY, ctx),
+            modelName: persisted.modelName ?? null,
+        }));
+    }
+    parsePersistedAdminSettings(value) {
+        if (value === undefined)
+            return {};
+        const settings = (0, n8n_workflow_1.jsonParse)(value, { fallbackValue: {} });
+        delete settings.modelCredentialId;
+        delete settings.daytonaCredentialId;
+        delete settings.n8nSandboxCredentialId;
+        delete settings.searchCredentialId;
+        return settings;
+    }
+    emitSettingsUpdated(previous, current) {
+        try {
+            this.eventService.emit('instance-ai-settings-updated', {
+                mcpSettingsChanged: current.mcpServers !== previous.mcpServers ||
+                    current.mcpAccessEnabled !== previous.mcpAccessEnabled,
+            });
+        }
+        catch (error) {
+            di_1.Container.get(backend_common_1.Logger)
+                .scoped('instance-ai')
+                .warn('Failed to apply local settings event', {
+                error: (0, ensure_error_1.ensureError)(error).message,
+            });
+        }
     }
 };
 exports.InstanceAiSettingsService = InstanceAiSettingsService;
 InstanceAiSettingsService.MANAGED_ADMIN_FIELDS = [
     'mcpServers',
     'sandboxEnabled',
-    'sandboxProvider',
     'sandboxImage',
     'sandboxTimeout',
+];
+InstanceAiSettingsService.INSTANCE_CREDENTIAL_FIELDS = [
+    'modelCredentialId',
     'daytonaCredentialId',
     'n8nSandboxCredentialId',
     'searchCredentialId',
+    'modelConnection',
+    'sandboxConnection',
+    'searchConnection',
 ];
 InstanceAiSettingsService.MANAGED_PREFERENCE_FIELDS = [
     'credentialId',
@@ -488,6 +964,6 @@ InstanceAiSettingsService.MANAGED_PREFERENCE_FIELDS = [
 ];
 exports.InstanceAiSettingsService = InstanceAiSettingsService = InstanceAiSettingsService_1 = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [config_1.GlobalConfig, db_1.SettingsRepository, db_1.UserRepository, user_service_1.UserService, ai_service_1.AiService, credentials_service_1.CredentialsService, credentials_finder_service_1.CredentialsFinderService, event_service_1.EventService])
+    __metadata("design:paramtypes", [config_1.GlobalConfig, db_1.DbLockService, db_1.SettingsRepository, db_1.UserRepository, user_service_1.UserService, ai_service_1.AiService, credentials_service_1.CredentialsService, credentials_finder_service_1.CredentialsFinderService, instance_credential_broker_1.InstanceCredentialBroker, event_service_1.EventService])
 ], InstanceAiSettingsService);
 //# sourceMappingURL=instance-ai-settings.service.js.map