n8n 2.41.4 → 2.42.1

package/dist/modules/agents/integrations/chat-integration.service.js

@@ -10,16 +10,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatIntegrationService = void 0;
+const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
+const constants_1 = require("@n8n/constants");
 const decorators_1 = require("@n8n/decorators");
 const di_1 = require("@n8n/di");
 const ensure_error_1 = require("@n8n/utils/errors/ensure-error");
+const deferred_promise_1 = require("@n8n/utils/promise/deferred-promise");
 const n8n_core_1 = require("n8n-core");
 const n8n_workflow_1 = require("n8n-workflow");
+const constants_2 = require("../../../constants");
 const credentials_service_1 = require("../../../credentials/credentials.service");
-const publisher_service_1 = require("../../../scaling/pubsub/publisher.service");
-const url_service_1 = require("../../../services/url.service");
+const backend_services_1 = require("@n8n/backend-services");
 const agent_chat_bridge_1 = require("./agent-chat-bridge");
 const agent_chat_integration_1 = require("./agent-chat-integration");
 const agent_chat_subscription_state_service_1 = require("./agent-chat-subscription-state.service");
@@ -29,21 +32,29 @@ const integration_tools_1 = require("./integration-tools");
 const leader_channel_relay_service_1 = require("./leader-channel-relay.service");
 const channel_integration_recorder_1 = require("./recording/channel-integration-recorder");
 const recording_adapter_1 = require("./recording/recording-adapter");
+const agent_change_publisher_service_1 = require("../agent-change-publisher.service");
+const agent_channel_1 = require("../utils/agent-channel");
 const agent_repository_1 = require("../repositories/agent.repository");
 const agent_channel_status_reporter_1 = require("./agent-channel-status-reporter");
+const SHUTDOWN_DRAIN_MS = 5 * constants_1.Time.seconds.toMilliseconds;
 async function getAgentExecutionOrchestratorService() {
     const { AgentExecutionOrchestratorService } = await import('../agent-execution-orchestrator.service.js');
     return di_1.Container.get(AgentExecutionOrchestratorService);
 }
+function streamingOptionsFor(type) {
+    if (type !== 'teams')
+        return {};
+    return { fallbackStreamingPlaceholderText: '…', streamingUpdateIntervalMs: 750 };
+}
 let ChatIntegrationService = class ChatIntegrationService {
-    constructor(logger, agentRepository, credentialsService, urlService, integrationRegistry, instanceSettings, publisher, globalConfig, chatSubscriptionStateService, statusReporter, leaderChannelRelay) {
+    constructor(logger, agentRepository, credentialsService, urlService, integrationRegistry, instanceSettings, changePublisher, globalConfig, chatSubscriptionStateService, statusReporter, leaderChannelRelay) {
         this.logger = logger;
         this.agentRepository = agentRepository;
         this.credentialsService = credentialsService;
         this.urlService = urlService;
         this.integrationRegistry = integrationRegistry;
         this.instanceSettings = instanceSettings;
-        this.publisher = publisher;
+        this.changePublisher = changePublisher;
         this.globalConfig = globalConfig;
         this.chatSubscriptionStateService = chatSubscriptionStateService;
         this.statusReporter = statusReporter;
@@ -52,29 +63,21 @@ let ChatIntegrationService = class ChatIntegrationService {
         this.outboundConnections = new Map();
         this.outboundConnectionInitializations = new Map();
         this.leaderOperations = new Map();
+        this.shuttingDown = false;
     }
     async broadcastIntegrationChange(agentId, integration, action) {
-        if (!this.globalConfig.multiMainSetup.enabled)
-            return;
-        try {
-            const payload = { agentId, integration, action };
-            await this.publisher.publishCommand({
-                command: 'agent-chat-integration-changed',
-                payload,
-            });
-        }
-        catch (error) {
-            this.logger.warn(`[ChatIntegrationService] Failed to publish ${action} for ${integration.type} on agent ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    connectionKey(agentId, type, credentialId) {
-        return `${agentId}:${type}:${credentialId}`;
+        await this.changePublisher.publish({
+            command: 'agent-chat-integration-changed',
+            payload: { agentId, integration, action },
+        });
     }
     integrationFromConnectionKey(key) {
         const type = key.split(':')[1];
         return type ? this.integrationRegistry.get(type) : undefined;
     }
     async assertStartupPreconditions(agentId, integration, projectId) {
+        if (!(0, api_types_1.isCredentialAgentIntegration)(integration))
+            return;
         const implementation = this.integrationRegistry.require(integration.type);
         await implementation.assertStartupPreconditions?.({
             agentId,
@@ -83,6 +86,8 @@ let ChatIntegrationService = class ChatIntegrationService {
         });
     }
     async validateBeforeConnect(agentId, integration, projectId) {
+        if (!(0, api_types_1.isCredentialAgentIntegration)(integration))
+            return;
         const implementation = this.integrationRegistry.require(integration.type);
         implementation.validateConfig?.(integration);
         if (!implementation.onBeforeConnect)
@@ -99,6 +104,8 @@ let ChatIntegrationService = class ChatIntegrationService {
         });
     }
     async connect(agentId, integration, projectId, options = {}) {
+        if (!(0, api_types_1.isCredentialAgentIntegration)(integration))
+            return;
         const ingress = options.ingressEnabled ?? true;
         if (!this.shouldRouteToLeader(integration.type, ingress)) {
             return await this.connectLocal(agentId, integration, projectId, options);
@@ -117,12 +124,17 @@ let ChatIntegrationService = class ChatIntegrationService {
         }
     }
     async connectLocal(agentId, integration, projectId, options = {}) {
+        if (this.shuttingDown) {
+            throw new n8n_workflow_1.OperationalError('This instance is shutting down and cannot start a channel', {
+                extra: { agentId, integrationType: integration.type },
+            });
+        }
         const ingressEnabled = options.ingressEnabled ?? true;
         if (!ingressEnabled) {
             await this.establishConnection(agentId, integration, projectId, options);
             return;
         }
-        const ref = this.channelRef(agentId, integration);
+        const ref = (0, agent_channel_1.agentChannelRef)(agentId, integration);
         try {
             await this.establishConnection(agentId, integration, projectId, options);
         }
@@ -133,7 +145,7 @@ let ChatIntegrationService = class ChatIntegrationService {
         await this.statusReporter.recordConnected(ref);
     }
     async establishConnection(agentId, integration, projectId, options = {}) {
-        const key = this.connectionKey(agentId, integration.type, integration.credentialId);
+        const key = (0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration));
         const ingressEnabled = options.ingressEnabled ?? true;
         if (ingressEnabled) {
             await this.disconnectOutboundOne(key);
@@ -142,82 +154,19 @@ let ChatIntegrationService = class ChatIntegrationService {
             }
         }
         const integrationImpl = this.integrationRegistry.require(integration.type);
-        const decryptedData = await this.decryptCredentialForProject(integration.credentialId, projectId);
-        const ctx = {
-            agentId,
-            projectId,
-            integration,
-            credentialId: integration.credentialId,
-            credential: decryptedData,
-            ingressEnabled,
-            webhookUrlFor: (platform) => this.buildWebhookUrl(agentId, projectId, platform),
-        };
+        const ctx = await this.createConnectionContext(agentId, projectId, integration, ingressEnabled);
         if (ingressEnabled && integrationImpl.onBeforeConnect && !options.skipExternalHooks) {
             await integrationImpl.onBeforeConnect(ctx);
         }
-        let state;
-        let chat;
-        let bridge;
-        let initializeStarted = false;
-        try {
-            const adapter = (0, recording_adapter_1.recordAdapterCalls)(integration.type, await integrationImpl.createAdapter(ctx));
-            channel_integration_recorder_1.channelIntegrationRecorder.startFetchRecording();
-            const { Chat } = await (0, esm_loader_1.loadChatSdk)();
-            const { createMemoryState } = await (0, esm_loader_1.loadMemoryState)();
-            const memoryState = createMemoryState();
-            state = ingressEnabled
-                ? this.chatSubscriptionStateService.createStateAdapter({
-                    agentId,
-                    integration,
-                    delegate: memoryState,
-                })
-                : memoryState;
-            chat = new Chat({
-                userName: `n8n-agent-${agentId}`,
-                adapters: { [integration.type]: adapter },
-                state,
-            });
-            if (ingressEnabled) {
-                const componentMapper = new component_mapper_1.ComponentMapper();
-                const agentExecutionOrchestratorService = await getAgentExecutionOrchestratorService();
-                bridge = agent_chat_bridge_1.AgentChatBridge.create(chat, agentId, agentExecutionOrchestratorService, componentMapper, this.logger, projectId, integration);
-            }
-            initializeStarted = true;
-            await chat.initialize();
-            if (ingressEnabled && integrationImpl.onAfterConnect && !options.skipExternalHooks) {
-                await integrationImpl.onAfterConnect(ctx);
-            }
-        }
-        catch (error) {
-            if (initializeStarted) {
-                await chat.shutdown().catch((shutdownError) => {
-                    this.logger.warn(`[ChatIntegrationService] Shutdown after failed connect threw: ${shutdownError instanceof Error ? shutdownError.message : String(shutdownError)}`);
-                });
-            }
-            else {
-                await state?.disconnect().catch((disconnectError) => {
-                    this.logger.warn(`[ChatIntegrationService] State cleanup after failed setup threw: ${disconnectError instanceof Error ? disconnectError.message : String(disconnectError)}`);
-                });
-            }
-            await this.runDisconnectedHook(integrationImpl, ctx, `${key} after failed connect`);
-            throw error;
-        }
-        const chatInstance = chat;
+        const { chat, bridge } = await this.initializeConnection(ctx, integrationImpl, options, key);
         const targetConnections = ingressEnabled ? this.connections : this.outboundConnections;
         targetConnections.set(key, {
-            chat: chatInstance,
+            chat,
             bridge,
             context: ctx,
-            ref: this.channelRef(agentId, integration),
+            ref: (0, agent_channel_1.agentChannelRef)(agentId, integration),
         });
-        if (integrationImpl.onConnected) {
-            try {
-                await integrationImpl.onConnected(ctx);
-            }
-            catch (error) {
-                this.logger.warn(`[ChatIntegrationService] onConnected failed for ${key}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
+        await this.runConnectedHook(integrationImpl, ctx, key);
         this.logger.info(`[ChatIntegrationService] ${ingressEnabled ? 'Connected' : 'Outbound connected'}: ${key}`);
     }
     async disconnect(agentId, integration, options = {}) {
@@ -244,6 +193,8 @@ let ChatIntegrationService = class ChatIntegrationService {
         await this.disconnectLocal(agentId, integration, { skipExternalHooks: true });
     }
     async disconnectChannel(agentId, integration, options = {}) {
+        if (!(0, api_types_1.isCredentialAgentIntegration)(integration))
+            return;
         const { deleteSubscriptions = true } = options;
         try {
             await this.disconnect(agentId, integration);
@@ -262,15 +213,19 @@ let ChatIntegrationService = class ChatIntegrationService {
         }
     }
     async disconnectAll() {
-        const keys = new Set([
+        this.shuttingDown = true;
+        await this.settleLeaderOperations(SHUTDOWN_DRAIN_MS);
+        for (const key of this.localRuntimeKeys()) {
+            await this.disconnectOne(key, { skipExternalHooks: true });
+            await this.disconnectOutboundOne(key);
+        }
+    }
+    localRuntimeKeys() {
+        return new Set([
             ...this.connections.keys(),
             ...this.outboundConnections.keys(),
             ...this.outboundConnectionInitializations.keys(),
         ]);
-        for (const key of keys) {
-            await this.disconnectOne(key, { skipExternalHooks: true });
-            await this.disconnectOutboundOne(key);
-        }
     }
     async disconnectLeaderOnlyIntegrations() {
         await this.settleLeaderOperations();
@@ -282,20 +237,22 @@ let ChatIntegrationService = class ChatIntegrationService {
         }
     }
     async syncToConfig(agent, previous, next) {
-        const previousKeys = new Set(previous.map(integration_tools_1.buildIntegrationConnectionId));
-        const nextKeys = new Set(next.map(integration_tools_1.buildIntegrationConnectionId));
-        for (const integration of previous) {
+        const previousExternal = previous.filter(api_types_1.isCredentialAgentIntegration);
+        const nextExternal = next.filter(api_types_1.isCredentialAgentIntegration);
+        const previousKeys = new Set(previousExternal.map(integration_tools_1.buildIntegrationConnectionId));
+        const nextKeys = new Set(nextExternal.map(integration_tools_1.buildIntegrationConnectionId));
+        for (const integration of previousExternal) {
             if (!nextKeys.has((0, integration_tools_1.buildIntegrationConnectionId)(integration))) {
                 await this.disconnectChannel(agent.id, integration);
             }
         }
-        const additions = next.filter((i) => !previousKeys.has((0, integration_tools_1.buildIntegrationConnectionId)(i)));
+        const additions = nextExternal.filter((integration) => !previousKeys.has((0, integration_tools_1.buildIntegrationConnectionId)(integration)));
         if (additions.length > 0 && !agent.activeVersionId) {
             this.logger.debug('[ChatIntegrationService] Skipping connect for unpublished agent — entry persisted, will connect on publish', { agentId: agent.id, pendingTypes: additions.map((i) => i.type) });
             return;
         }
         for (const integration of additions) {
-            const key = this.connectionKey(agent.id, integration.type, integration.credentialId);
+            const key = (0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agent.id, integration));
             if (this.connections.has(key))
                 continue;
             try {
@@ -314,17 +271,32 @@ let ChatIntegrationService = class ChatIntegrationService {
     }
     getChatInstance(agentId, integration) {
         if (integration) {
-            return this.connections.get(this.connectionKey(agentId, integration.type, integration.credentialId))?.chat;
+            return this.connections.get((0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration)))?.chat;
         }
         return this.findConnection(agentId)?.chat;
     }
     getBridge(agentId, integrationType, credentialId) {
         if (credentialId !== undefined) {
-            return this.connections.get(this.connectionKey(agentId, integrationType, credentialId))
+            return this.connections.get((0, agent_channel_1.agentChannelKey)({ agentId, integrationType, credentialId }))
                 ?.bridge;
         }
         return this.findConnection(agentId, integrationType, (c) => c.bridge !== undefined)?.bridge;
     }
+    acquireQueueBridge(agentId, integrationType, credentialId) {
+        const connection = this.connections.get((0, agent_channel_1.agentChannelKey)({ agentId, integrationType, credentialId }));
+        if (!connection?.bridge || connection.disconnecting)
+            return undefined;
+        const done = (0, deferred_promise_1.createDeferredPromise)();
+        connection.queueConsumers ??= new Set();
+        connection.queueConsumers.add(done.promise);
+        return {
+            bridge: connection.bridge,
+            release: () => {
+                connection.queueConsumers?.delete(done.promise);
+                done.resolve();
+            },
+        };
+    }
     findConnection(agentId, integrationType, predicate) {
         const prefix = integrationType ? `${agentId}:${integrationType}:` : `${agentId}:`;
         for (const [key, connection] of this.connections) {
@@ -342,21 +314,16 @@ let ChatIntegrationService = class ChatIntegrationService {
         const live = this.getChatInstance(agentId, integration);
         if (live)
             return live;
-        const key = this.connectionKey(agentId, integration.type, integration.credentialId);
-        const handleInitializationError = (error) => {
-            this.logger.warn('[ChatIntegrationService] Could not initialize outbound integration for Preview', {
-                agentId,
-                type: integration.type,
-                credentialId: integration.credentialId,
-                error,
-            });
-            return undefined;
-        };
+        const key = (0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration));
+        const handleInitializationError = (error) => this.reportOutboundError(agentId, integration, error);
         const agent = await this.agentRepository
             .findOne({ where: { id: agentId } })
             .catch(handleInitializationError);
         const persistedIntegration = agent?.integrations?.find((candidate) => candidate.type === integration.type && candidate.credentialId === integration.credentialId);
-        if (!agent || agent.activeVersionId !== null || !persistedIntegration) {
+        const ingressOwnedByLeader = this.shouldRouteToLeader(integration.type, true);
+        if (!agent ||
+            !persistedIntegration ||
+            (agent.activeVersionId !== null && !ingressOwnedByLeader)) {
             await this.disconnectOutboundOne(key);
             return undefined;
         }
@@ -366,27 +333,11 @@ let ChatIntegrationService = class ChatIntegrationService {
         const outbound = this.outboundConnections.get(key)?.chat;
         if (outbound)
             return outbound;
-        const pending = this.outboundConnectionInitializations.get(key);
-        if (pending)
-            return await pending;
-        const initialization = this.connect(agentId, persistedIntegration, agent.projectId, {
-            ingressEnabled: false,
-        })
-            .then(() => this.outboundConnections.get(key)?.chat)
-            .catch(handleInitializationError);
-        this.outboundConnectionInitializations.set(key, initialization);
-        try {
-            return await initialization;
-        }
-        finally {
-            if (this.outboundConnectionInitializations.get(key) === initialization) {
-                this.outboundConnectionInitializations.delete(key);
-            }
-        }
+        return await this.initializeOutboundConnection(key, agent, persistedIntegration);
     }
     getShortenCallback(agentId, integration, metadata) {
         return this.connections
-            .get(this.connectionKey(agentId, integration.type, integration.credentialId))
+            .get((0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration)))
             ?.bridge?.getShortenCallback(metadata);
     }
     getWebhookHandler(agentId, platform, connectionSelector) {
@@ -406,7 +357,7 @@ let ChatIntegrationService = class ChatIntegrationService {
         return [...this.connections.values()].map((conn) => conn.ref);
     }
     hasLiveChannel(ref) {
-        return this.connections.has(this.connectionKey(ref.agentId, ref.integrationType, ref.credentialId));
+        return this.connections.has((0, agent_channel_1.agentChannelKey)(ref));
     }
     async startChannel(agent, integration) {
         const skipExternalHooks = !this.instanceSettings.isLeader;
@@ -424,7 +375,7 @@ let ChatIntegrationService = class ChatIntegrationService {
             this.logger.debug(`[ChatIntegrationService] Ignoring connect for ${type} on agent ${agentId} — leader-only integration on follower`);
             return;
         }
-        const key = this.connectionKey(agentId, type, credentialId);
+        const key = (0, agent_channel_1.agentChannelKey)({ agentId, integrationType: type, credentialId });
         if (this.connections.has(key))
             return;
         const agent = await this.agentRepository.findOne({ where: { id: agentId } });
@@ -442,23 +393,9 @@ let ChatIntegrationService = class ChatIntegrationService {
     }
     async handleLeaderChannelRequest(payload) {
         const { agentId, integration, action } = payload;
-        const key = this.connectionKey(agentId, integration.type, integration.credentialId);
+        const key = (0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration));
         try {
-            await this.runLeaderOperation(key, action, async () => {
-                if (action === 'disconnect') {
-                    await this.disconnectLocal(agentId, integration);
-                    return;
-                }
-                const agent = await this.agentRepository.findOne({ where: { id: agentId } });
-                if (!agent) {
-                    throw new n8n_workflow_1.UnexpectedError(`Agent ${agentId} not found on the leader instance`);
-                }
-                await this.connectLocal(agentId, integration, agent.projectId);
-                if (!this.instanceSettings.isLeader) {
-                    await this.disconnectOne(key, { skipExternalHooks: true });
-                    throw new n8n_workflow_1.OperationalError('This instance stopped being the leader while the channel was starting up');
-                }
-            });
+            await this.runLeaderOperation(key, action, async () => await this.applyLeaderChannelRequest(payload, key));
             await this.leaderChannelRelay.respond(payload);
         }
         catch (error) {
@@ -467,13 +404,6 @@ let ChatIntegrationService = class ChatIntegrationService {
             await this.leaderChannelRelay.respond(payload, failure);
         }
     }
-    channelRef(agentId, integration) {
-        return {
-            agentId,
-            integrationType: integration.type,
-            credentialId: integration.credentialId,
-        };
-    }
     shouldRouteToLeader(type, ingressEnabled) {
         return (this.globalConfig.multiMainSetup.enabled &&
             !this.instanceSettings.isLeader &&
@@ -500,7 +430,7 @@ let ChatIntegrationService = class ChatIntegrationService {
                 this.leaderOperations.delete(key);
         }
     }
-    async settleLeaderOperations() {
+    async settleLeaderOperations(timeoutMs = leader_channel_relay_service_1.LEADER_CHANNEL_REQUEST_TIMEOUT_MS) {
         const running = [...this.leaderOperations.values()];
         if (running.length === 0)
             return;
@@ -509,7 +439,7 @@ let ChatIntegrationService = class ChatIntegrationService {
             await Promise.race([
                 Promise.allSettled(running.map(async ({ done }) => await done)),
                 new Promise((resolve) => {
-                    expire = setTimeout(resolve, leader_channel_relay_service_1.LEADER_CHANNEL_REQUEST_TIMEOUT_MS);
+                    expire = setTimeout(resolve, timeoutMs);
                 }),
             ]);
         }
@@ -518,7 +448,7 @@ let ChatIntegrationService = class ChatIntegrationService {
         }
     }
     async disconnectLocal(agentId, integration, options = {}) {
-        const key = this.connectionKey(agentId, integration.type, integration.credentialId);
+        const key = (0, agent_channel_1.agentChannelKey)((0, agent_channel_1.agentChannelRef)(agentId, integration));
         await this.disconnectOne(key, options);
         await this.disconnectOutboundOne(key);
     }
@@ -544,17 +474,11 @@ let ChatIntegrationService = class ChatIntegrationService {
         const conn = this.connections.get(key);
         if (!conn)
             return;
-        if (!options.skipExternalHooks) {
-            const integration = this.integrationFromConnectionKey(key);
-            if (integration?.onBeforeDisconnect) {
-                try {
-                    await integration.onBeforeDisconnect(conn.context);
-                }
-                catch (error) {
-                    this.logger.warn(`[ChatIntegrationService] onBeforeDisconnect failed for ${key}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
+        conn.disconnecting = true;
+        if (conn.queueConsumers)
+            await Promise.all(conn.queueConsumers);
+        if (!options.skipExternalHooks)
+            await this.runBeforeDisconnectHook(key, conn.context);
         try {
             await conn.chat.shutdown();
         }
@@ -596,8 +520,154 @@ let ChatIntegrationService = class ChatIntegrationService {
             ? { skipExternalHooks, settings: integration.settings }
             : { skipExternalHooks };
     }
+    async createConnectionContext(agentId, projectId, integration, ingressEnabled) {
+        const decryptedData = await this.decryptCredentialForProject(integration.credentialId, projectId);
+        return {
+            agentId,
+            projectId,
+            integration,
+            credentialId: integration.credentialId,
+            credential: decryptedData,
+            ingressEnabled,
+            webhookUrlFor: (platform) => this.buildWebhookUrl(agentId, projectId, platform),
+        };
+    }
+    async initializeConnection(ctx, integrationImpl, options, key) {
+        const { agentId, integration, ingressEnabled } = ctx;
+        let state;
+        let chat;
+        let bridge;
+        let initializeStarted = false;
+        try {
+            const adapter = (0, recording_adapter_1.recordAdapterCalls)(integration.type, await integrationImpl.createAdapter(ctx));
+            channel_integration_recorder_1.channelIntegrationRecorder.startFetchRecording();
+            const { Chat } = await (0, esm_loader_1.loadChatSdk)();
+            const { createMemoryState } = await (0, esm_loader_1.loadMemoryState)();
+            const memoryState = createMemoryState();
+            state = ingressEnabled
+                ? this.chatSubscriptionStateService.createStateAdapter({
+                    agentId,
+                    integration,
+                    delegate: memoryState,
+                })
+                : memoryState;
+            chat = new Chat({
+                concurrency: 'concurrent',
+                userName: `n8n-agent-${agentId}`,
+                adapters: { [integration.type]: adapter },
+                state,
+                ...streamingOptionsFor(integration.type),
+            });
+            if (ingressEnabled)
+                bridge = await this.createChatBridge(chat, ctx);
+            initializeStarted = true;
+            await chat.initialize();
+            if (ingressEnabled && integrationImpl.onAfterConnect && !options.skipExternalHooks) {
+                await integrationImpl.onAfterConnect(ctx);
+            }
+            if (this.shuttingDown) {
+                throw new n8n_workflow_1.OperationalError('This instance started shutting down while the channel was starting up');
+            }
+        }
+        catch (error) {
+            await this.cleanupFailedConnection(chat, state, initializeStarted);
+            await this.runDisconnectedHook(integrationImpl, ctx, `${key} after failed connect`);
+            throw error;
+        }
+        return { chat: chat, bridge };
+    }
+    async createChatBridge(chat, ctx) {
+        const { agentId, projectId, integration } = ctx;
+        const componentMapper = new component_mapper_1.ComponentMapper();
+        const agentExecutionOrchestratorService = await getAgentExecutionOrchestratorService();
+        return agent_chat_bridge_1.AgentChatBridge.create(chat, agentId, agentExecutionOrchestratorService, componentMapper, this.logger, projectId, integration);
+    }
+    async cleanupFailedConnection(chat, state, initializeStarted) {
+        if (initializeStarted) {
+            await chat.shutdown().catch((shutdownError) => {
+                this.logger.warn(`[ChatIntegrationService] Shutdown after failed connect threw: ${shutdownError instanceof Error ? shutdownError.message : String(shutdownError)}`);
+            });
+        }
+        else {
+            await state?.disconnect().catch((disconnectError) => {
+                this.logger.warn(`[ChatIntegrationService] State cleanup after failed setup threw: ${disconnectError instanceof Error ? disconnectError.message : String(disconnectError)}`);
+            });
+        }
+    }
+    async runConnectedHook(integrationImpl, ctx, key) {
+        if (!integrationImpl.onConnected)
+            return;
+        try {
+            await integrationImpl.onConnected(ctx);
+        }
+        catch (error) {
+            this.logger.warn(`[ChatIntegrationService] onConnected failed for ${key}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    reportOutboundError(agentId, integration, error) {
+        this.logger.warn('[ChatIntegrationService] Could not initialize outbound integration for Preview', {
+            agentId,
+            type: integration.type,
+            credentialId: integration.credentialId,
+            error,
+        });
+        return undefined;
+    }
+    async initializeOutboundConnection(key, agent, integration) {
+        const agentId = agent.id;
+        const handleInitializationError = (error) => this.reportOutboundError(agentId, integration, error);
+        const pending = this.outboundConnectionInitializations.get(key);
+        if (pending)
+            return await pending;
+        const initialization = this.connect(agentId, integration, agent.projectId, {
+            ingressEnabled: false,
+        })
+            .then(() => this.outboundConnections.get(key)?.chat)
+            .catch(handleInitializationError);
+        this.outboundConnectionInitializations.set(key, initialization);
+        try {
+            return await initialization;
+        }
+        finally {
+            if (this.outboundConnectionInitializations.get(key) === initialization) {
+                this.outboundConnectionInitializations.delete(key);
+            }
+        }
+    }
+    async applyLeaderChannelRequest({ agentId, integration, action }, key) {
+        if (action === 'disconnect') {
+            await this.disconnectLocal(agentId, integration);
+            return;
+        }
+        const agent = await this.agentRepository.findOne({ where: { id: agentId } });
+        if (!agent) {
+            throw new n8n_workflow_1.UnexpectedError(`Agent ${agentId} not found on the leader instance`);
+        }
+        await this.connectLocal(agentId, integration, agent.projectId);
+        if (!this.instanceSettings.isLeader) {
+            await this.disconnectOne(key, { skipExternalHooks: true });
+            throw new n8n_workflow_1.OperationalError('This instance stopped being the leader while the channel was starting up');
+        }
+    }
+    async runBeforeDisconnectHook(key, context) {
+        const integration = this.integrationFromConnectionKey(key);
+        if (!integration?.onBeforeDisconnect)
+            return;
+        try {
+            await integration.onBeforeDisconnect(context);
+        }
+        catch (error) {
+            this.logger.warn(`[ChatIntegrationService] onBeforeDisconnect failed for ${key}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 };
 exports.ChatIntegrationService = ChatIntegrationService;
+__decorate([
+    (0, decorators_1.OnShutdown)(constants_2.LOWEST_SHUTDOWN_PRIORITY),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ChatIntegrationService.prototype, "disconnectAll", null);
 __decorate([
     (0, decorators_1.OnLeaderStepdown)(),
     __metadata("design:type", Function),
@@ -621,6 +691,6 @@ __decorate([
 ], ChatIntegrationService.prototype, "handleLeaderChannelRequest", null);
 exports.ChatIntegrationService = ChatIntegrationService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, agent_repository_1.AgentRepository, credentials_service_1.CredentialsService, url_service_1.UrlService, agent_chat_integration_1.ChatIntegrationRegistry, n8n_core_1.InstanceSettings, publisher_service_1.Publisher, config_1.GlobalConfig, agent_chat_subscription_state_service_1.AgentChatSubscriptionStateService, agent_channel_status_reporter_1.AgentChannelStatusReporter, leader_channel_relay_service_1.LeaderChannelRelayService])
+    __metadata("design:paramtypes", [backend_common_1.Logger, agent_repository_1.AgentRepository, credentials_service_1.CredentialsService, backend_services_1.UrlService, agent_chat_integration_1.ChatIntegrationRegistry, n8n_core_1.InstanceSettings, agent_change_publisher_service_1.AgentChangePublisher, config_1.GlobalConfig, agent_chat_subscription_state_service_1.AgentChatSubscriptionStateService, agent_channel_status_reporter_1.AgentChannelStatusReporter, leader_channel_relay_service_1.LeaderChannelRelayService])
 ], ChatIntegrationService);
 //# sourceMappingURL=chat-integration.service.js.map