n8n 2.28.4 → 2.29.1

package/dist/modules/agents/integrations/agent-chat-bridge.js

@@ -2,97 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentChatBridge = void 0;
 const di_1 = require("@n8n/di");
-const utils_1 = require("@n8n/utils");
 const agent_memory_scope_1 = require("../utils/agent-memory-scope");
 const agent_chat_integration_1 = require("./agent-chat-integration");
+const agent_chat_hitl_resume_handler_1 = require("./agent-chat-hitl-resume-handler");
+const agent_chat_message_context_1 = require("./agent-chat-message-context");
+const agent_chat_stream_consumer_1 = require("./agent-chat-stream-consumer");
+const agent_chat_suspension_cards_1 = require("./agent-chat-suspension-cards");
 const callback_store_1 = require("./callback-store");
 const integration_message_context_service_1 = require("./integration-message-context.service");
-const integration_tools_1 = require("./integration-tools");
 const types_1 = require("./types");
-const SLACK_THINKING_STATUS = 'Thinking...';
-const SLACK_STATUS_RETRY_DELAY_MS = 750;
-const APPROVAL_INPUT_MAX_LENGTH = 1500;
-function isIntegrationActionSuspendPayload(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'type' in value &&
-        value.type === 'integration_action');
-}
-function isApprovalSuspendPayload(value) {
-    return ((0, utils_1.isRecord)(value) &&
-        value.type === 'approval' &&
-        typeof value.toolName === 'string' &&
-        value.toolName.length > 0);
-}
-function truncateApprovalInput(value) {
-    if (value.length <= APPROVAL_INPUT_MAX_LENGTH)
-        return value;
-    return `${value.slice(0, APPROVAL_INPUT_MAX_LENGTH)}...`;
-}
-function stringifyApprovalInput(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value === 'string') {
-        return truncateApprovalInput(value);
-    }
-    try {
-        const serialized = JSON.stringify(value, null, 2);
-        return truncateApprovalInput(serialized ?? String(value));
-    }
-    catch {
-        return truncateApprovalInput(String(value));
-    }
-}
-function getApprovalToolLabel(payload) {
-    return typeof payload.displayName === 'string' && payload.displayName.length > 0
-        ? payload.displayName
-        : payload.toolName;
-}
-function buildApprovalCardPayload(payload) {
-    const toolLabel = getApprovalToolLabel(payload);
-    const fields = [{ label: 'Tool', value: toolLabel }];
-    const input = stringifyApprovalInput(payload.args);
-    if (input) {
-        fields.push({ label: 'Input', value: input });
-    }
-    return {
-        title: 'Approval required',
-        components: [
-            { type: 'section', text: `The agent wants to run this tool: ${toolLabel}` },
-            { type: 'fields', fields },
-            { type: 'button', label: 'Approve', value: 'true', style: 'primary' },
-            { type: 'button', label: 'Deny', value: 'false', style: 'danger' },
-        ],
-    };
-}
-function toIntegrationMessageSubject(subject) {
-    if (!subject || typeof subject.type !== 'string' || typeof subject.id !== 'string') {
-        return undefined;
-    }
-    const assignee = toIntegrationSubjectPerson(subject.assignee);
-    const author = toIntegrationSubjectPerson(subject.author);
-    const labels = subject.labels?.filter((label) => typeof label === 'string');
-    return {
-        type: subject.type,
-        id: subject.id,
-        ...(typeof subject.title === 'string' ? { title: subject.title } : {}),
-        ...(typeof subject.description === 'string' ? { description: subject.description } : {}),
-        ...(typeof subject.url === 'string' ? { url: subject.url } : {}),
-        ...(typeof subject.status === 'string' ? { status: subject.status } : {}),
-        ...(labels && labels.length > 0 ? { labels } : {}),
-        ...(assignee ? { assignee } : {}),
-        ...(author ? { author } : {}),
-    };
-}
-function toIntegrationSubjectPerson(person) {
-    if (!person || typeof person.id !== 'string' || typeof person.name !== 'string') {
-        return undefined;
-    }
-    return {
-        id: person.id,
-        name: person.name,
-    };
-}
 class AgentChatBridge {
     constructor(chat, agentId, agentService, componentMapper, logger, n8nProjectId, integration, messageContextStore) {
         this.chat = chat;
@@ -102,13 +20,44 @@ class AgentChatBridge {
         this.logger = logger;
         this.n8nProjectId = n8nProjectId;
         this.integration = integration;
-        this.messageContextStore = messageContextStore;
-        this.activeResumedRuns = new Set();
         this.integrationImpl = di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry).get(integration.type);
+        this.messageContextBridge = new agent_chat_message_context_1.AgentChatMessageContextBridge(messageContextStore, integration, agentId, logger);
         if (this.integrationImpl?.needsShortCallbackData) {
             this.callbackStore = new callback_store_1.CallbackStore();
         }
-        this.disableStreaming = this.integrationImpl?.disableStreaming ?? false;
+        const disableStreaming = this.integrationImpl?.disableStreaming ?? false;
+        this.streamConsumer = new agent_chat_stream_consumer_1.AgentChatStreamConsumer({
+            disableStreaming,
+            logger: this.logger,
+            postErrorToThread: this.postErrorToThread.bind(this),
+            handleSuspension: this.handleSuspension.bind(this),
+            handleMessage: this.handleMessage.bind(this),
+        });
+        this.hitlResumeHandler = new agent_chat_hitl_resume_handler_1.AgentChatHitlResumeHandler({
+            agentId,
+            projectId: n8nProjectId,
+            integration,
+            agentService,
+            logger,
+            callbackStore: this.callbackStore,
+            resolvePlatformThreadId: this.resolvePlatformThreadId.bind(this),
+            toAgentThreadId: this.toAgentThreadId.bind(this),
+            getPlatformAgentContext: this.getPlatformAgentContext.bind(this),
+            messageContextBridge: this.messageContextBridge,
+            streamConsumer: this.streamConsumer,
+            createResumeExecutionContext: async (thread) => {
+                const params = {
+                    chat: this.chat,
+                    thread,
+                    logger: this.logger,
+                    agentId: this.agentId,
+                };
+                const resumeExecutionContext = await this.integrationImpl?.createResumeExecutionContext?.(params);
+                if (resumeExecutionContext)
+                    return resumeExecutionContext;
+                return {};
+            },
+        });
         this.registerHandlers();
     }
     static create(chat, agentId, agentService, componentMapper, logger, n8nProjectId, integration) {
@@ -160,7 +109,7 @@ class AgentChatBridge {
             try {
                 if (!this.canUserAccess(event.user))
                     return;
-                await this.handleAction(event);
+                await this.hitlResumeHandler.handleAction(event);
             }
             catch (error) {
                 await this.postErrorToThread(event.thread, error);
@@ -195,17 +144,15 @@ class AgentChatBridge {
             return;
         const platformThreadId = this.resolvePlatformThreadId(thread);
         const threadId = this.toAgentThreadId(platformThreadId);
-        const slackThreadContext = this.getSlackThreadContext(message);
-        const useNativeSlackThreadFeatures = this.integration.type !== 'slack' || slackThreadContext?.hasRealThreadTs === true;
         const statusRetry = new AbortController();
-        const [statusHandle, subject] = await Promise.all([
-            this.startThinkingStatus(thread, slackThreadContext, statusRetry),
-            this.resolveMessageSubject(message),
+        const [bridgeExecutionContext, subject] = await Promise.all([
+            this.resolveBridgeExecutionContext(thread, message, platformAgentContext, statusRetry),
+            this.messageContextBridge.resolveSubject(message),
         ]);
-        await this.updateLatestMessageContext(threadId.id, message.author.userId, thread, {
+        await this.messageContextBridge.updateLatest(threadId.id, message.author.userId, thread, {
             messageId: message.id,
             interactingUserId: message.author.userId,
-            ...platformAgentContext,
+            ...bridgeExecutionContext.platformAgentContext,
             subject,
         });
         const stream = this.agentService.executeForChatPublished({
@@ -219,208 +166,24 @@ class AgentChatBridge {
             integrationType: this.integration.type,
         });
         try {
-            await this.consumeStream(stream, thread, {
-                forceBuffered: this.integration.type === 'slack' && !useNativeSlackThreadFeatures,
-                statusHandle,
+            await this.streamConsumer.consume(stream, thread, {
+                forceBuffered: bridgeExecutionContext.forceBuffered,
+                statusHandle: bridgeExecutionContext.statusHandle,
             });
         }
         finally {
             statusRetry.abort();
         }
     }
-    async consumeStream(stream, thread, options = {}) {
-        if (this.disableStreaming || options.forceBuffered) {
-            await this.consumeStreamBuffered(stream, thread, {
-                statusHandle: options.statusHandle,
-            });
-            return;
-        }
-        const textStream = {
-            yield: null,
-            end: null,
-        };
-        let streamingPost = null;
-        const createTextIterable = () => {
-            const queue = [];
-            let done = false;
-            let waiting = null;
-            textStream.yield = (text) => {
-                if (waiting) {
-                    const resolve = waiting;
-                    waiting = null;
-                    resolve({ value: text, done: false });
-                }
-                else {
-                    queue.push(text);
-                }
-            };
-            textStream.end = () => {
-                done = true;
-                if (waiting) {
-                    const resolve = waiting;
-                    waiting = null;
-                    resolve({ value: '', done: true });
-                }
-            };
-            return {
-                [Symbol.asyncIterator]() {
-                    return {
-                        async next() {
-                            if (queue.length > 0) {
-                                return { value: queue.shift(), done: false };
-                            }
-                            if (done) {
-                                return { value: '', done: true };
-                            }
-                            return await new Promise((resolve) => {
-                                waiting = resolve;
-                            });
-                        },
-                    };
-                },
-            };
-        };
-        const startStreamingPost = () => {
-            const iterable = createTextIterable();
-            streamingPost = thread.post(iterable).catch((postError) => {
-                this.logger.error('[AgentChatBridge] Streaming post failed', {
-                    error: postError instanceof Error ? postError.message : String(postError),
-                });
-            });
-        };
-        const endStreamingPost = async () => {
-            if (textStream.end) {
-                textStream.end();
-                textStream.end = null;
-                textStream.yield = null;
-            }
-            if (streamingPost) {
-                await streamingPost;
-                streamingPost = null;
-            }
-        };
-        const ensureStreamingPost = () => {
-            if (!streamingPost)
-                startStreamingPost();
-        };
-        const responseLifecycle = this.createResponseLifecycle({
-            statusHandle: options.statusHandle,
-            ensureStreamingPost,
-            endStreamingPost,
-        });
-        try {
-            for await (const chunk of stream) {
-                switch (chunk.type) {
-                    case 'text-delta': {
-                        const { delta } = chunk;
-                        await responseLifecycle.startStreamingResponse();
-                        textStream.yield?.(delta);
-                        break;
-                    }
-                    case 'reasoning-delta': {
-                        const { delta } = chunk;
-                        await responseLifecycle.startStreamingResponse();
-                        textStream.yield?.(`_${delta}_`);
-                        break;
-                    }
-                    case 'tool-call-suspended':
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.handleSuspension(chunk, thread);
-                        break;
-                    case 'message':
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.handleMessage(chunk, thread);
-                        break;
-                    case 'error':
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.postErrorToThread(thread, chunk.error);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-        finally {
-            await responseLifecycle.finish();
-        }
-    }
-    createResponseLifecycle(options) {
-        let responseStarted = false;
-        const clearStatusBeforeFirstResponse = async () => {
-            if (responseStarted)
-                return;
-            responseStarted = true;
-            await options.statusHandle?.clearBeforeResponse();
-        };
-        return {
-            startStreamingResponse: async () => {
-                await clearStatusBeforeFirstResponse();
-                options.ensureStreamingPost?.();
-            },
-            startDiscreteResponse: async () => {
-                await options.endStreamingPost?.();
-                await clearStatusBeforeFirstResponse();
-            },
-            finish: async () => {
-                await options.endStreamingPost?.();
-                await clearStatusBeforeFirstResponse();
-            },
-        };
-    }
-    async consumeStreamBuffered(stream, thread, options = {}) {
-        let buffer = '';
-        const responseLifecycle = this.createResponseLifecycle({
-            statusHandle: options.statusHandle,
-        });
-        const flushBuffer = async () => {
-            const text = buffer;
-            buffer = '';
-            if (!text.trim())
-                return;
-            try {
-                await responseLifecycle.startDiscreteResponse();
-                await thread.post({ markdown: text });
-            }
-            catch (postError) {
-                await this.postErrorToThread(thread, postError);
-                this.logger.error('[AgentChatBridge] Buffered post failed', {
-                    error: postError instanceof Error ? postError.message : String(postError),
-                });
-            }
-        };
-        try {
-            for await (const chunk of stream) {
-                switch (chunk.type) {
-                    case 'text-delta':
-                        buffer += chunk.delta;
-                        break;
-                    case 'reasoning-delta':
-                        buffer += `_${chunk.delta}_`;
-                        break;
-                    case 'tool-call-suspended':
-                        await flushBuffer();
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.handleSuspension(chunk, thread);
-                        break;
-                    case 'message':
-                        await flushBuffer();
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.handleMessage(chunk, thread);
-                        break;
-                    case 'error':
-                        await flushBuffer();
-                        await responseLifecycle.startDiscreteResponse();
-                        await this.postErrorToThread(thread, chunk.error);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-        finally {
-            await flushBuffer();
-            await responseLifecycle.finish();
-        }
+    async resolveBridgeExecutionContext(thread, message, platformAgentContext, statusRetry) {
+        return ((await this.integrationImpl?.createBridgeExecutionContext?.({
+            chat: this.chat,
+            thread,
+            message,
+            logger: this.logger,
+            agentId: this.agentId,
+            statusRetry,
+        })) ?? { platformAgentContext });
     }
     async handleSuspension(chunk, thread) {
         const { runId, toolCallId, suspendPayload } = chunk;
@@ -428,33 +191,9 @@ class AgentChatBridge {
             this.logger.warn('[AgentChatBridge] Suspended chunk missing runId or toolCallId');
             return;
         }
-        const payload = suspendPayload;
-        if (isIntegrationActionSuspendPayload(payload)) {
+        const cardPayload = (0, agent_chat_suspension_cards_1.buildSuspendCardPayload)(suspendPayload);
+        if (!cardPayload)
             return;
-        }
-        const hasComponents = payload &&
-            'components' in payload &&
-            Array.isArray(payload.components) &&
-            payload.components.length > 0;
-        let cardPayload;
-        if (isApprovalSuspendPayload(payload)) {
-            cardPayload = buildApprovalCardPayload(payload);
-        }
-        else if (hasComponents) {
-            cardPayload = payload;
-        }
-        else {
-            const message = payload && typeof payload === 'object' && 'message' in payload
-                ? String(payload.message)
-                : 'Action required — approve or deny?';
-            cardPayload = {
-                title: message,
-                components: [
-                    { type: 'button', label: 'Approve', value: 'true', style: 'primary' },
-                    { type: 'button', label: 'Deny', value: 'false', style: 'danger' },
-                ],
-            };
-        }
         try {
             const card = await this.componentMapper.toCard(cardPayload, runId, toolCallId, chunk.resumeSchema, this.getShortenCallback(), this.integration.type);
             await thread.post({ card });
@@ -489,296 +228,12 @@ class AgentChatBridge {
             });
         }
     }
-    parseActionId(actionId, value) {
-        if (actionId.startsWith('ri-sel:')) {
-            const parts = actionId.split(':');
-            if (parts.length < 4) {
-                this.logger.warn('[AgentChatBridge] Malformed ri-sel action ID', { actionId });
-                return null;
-            }
-            return {
-                runId: parts[2],
-                toolCallId: parts.slice(3).join(':'),
-                resumeData: { type: 'select', id: parts[1], value },
-            };
-        }
-        if (actionId.startsWith('resume:')) {
-            const parts = actionId.split(':');
-            if (parts.length < 4) {
-                this.logger.warn('[AgentChatBridge] Malformed action ID', { actionId });
-                return null;
-            }
-            let resumeData;
-            try {
-                resumeData = JSON.parse(value ?? '');
-            }
-            catch {
-                resumeData = { value };
-            }
-            return { runId: parts[1], toolCallId: parts.slice(2, -1).join(':'), resumeData };
-        }
-        return null;
-    }
-    async resolveCallbackData(actionId, value, thread) {
-        if (!this.callbackStore)
-            return { actionId, value };
-        const resolved = await this.callbackStore.resolve(actionId);
-        if (!resolved) {
-            this.logger.warn('[AgentChatBridge] Callback key not found or expired', { actionId });
-            await thread.post('This action is no longer available. The link may have expired or already been used.');
-            return null;
-        }
-        return { actionId: resolved.actionId, value: resolved.value };
-    }
-    async cleanUpBeforeResume(event) {
-        try {
-            await event.adapter.deleteMessage(event.threadId, event.messageId);
-        }
-        catch (deleteError) {
-            this.logger.warn('[AgentChatBridge] Failed to delete card message', {
-                error: deleteError instanceof Error ? deleteError.message : String(deleteError),
-            });
-        }
-    }
-    async executeResume(thread, runId, toolCallId, resumeData) {
-        if (this.activeResumedRuns.has(runId)) {
-            this.logger.warn('[AgentChatBridge] Run is already active', { runId, toolCallId });
-            await thread.post('This action has already been handled');
-            return;
-        }
-        this.activeResumedRuns.add(runId);
-        try {
-            await this.startThinkingStatus(thread);
-            const stream = this.agentService.resumeForChat({
-                agentId: this.agentId,
-                projectId: this.n8nProjectId,
-                runId,
-                toolCallId,
-                resumeData,
-                integrationType: this.integration.type,
-            });
-            await this.consumeStream(stream, thread);
-        }
-        finally {
-            this.activeResumedRuns.delete(runId);
-        }
-    }
-    async startThinkingStatus(thread, slackThreadContext, statusRetry) {
-        if (this.integration.type !== 'slack')
-            return;
-        if (slackThreadContext && !slackThreadContext.hasRealThreadTs) {
-            const setStatus = this.setSlackAssistantStatus(slackThreadContext, statusRetry?.signal);
-            return slackThreadContext.isDm
-                ? {
-                    clearBeforeResponse: async () => {
-                        statusRetry?.abort();
-                        await setStatus;
-                        await this.clearSlackAssistantStatus(slackThreadContext);
-                    },
-                }
-                : undefined;
-        }
-        try {
-            await thread.startTyping(SLACK_THINKING_STATUS);
-        }
-        catch (error) {
-            this.logger.warn('[AgentChatBridge] Failed to set Slack assistant status', {
-                agentId: this.agentId,
-                threadId: thread.id,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        return undefined;
-    }
-    async setSlackAssistantStatus(context, statusRetrySignal) {
-        const adapter = this.getSlackAssistantStatusAdapter();
-        if (!adapter)
-            return;
-        await this.setSlackAssistantStatusWithRetry(adapter, context, statusRetrySignal);
-    }
-    async clearSlackAssistantStatus(context) {
-        const adapter = this.getSlackAssistantStatusAdapter();
-        if (!adapter)
-            return;
-        try {
-            await adapter.setAssistantStatus(context.channelId, context.threadTs, '');
-        }
-        catch (error) {
-            this.logger.warn('[AgentChatBridge] Failed to clear Slack assistant status', {
-                agentId: this.agentId,
-                channelId: context.channelId,
-                threadTs: context.threadTs,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async setSlackAssistantStatusWithRetry(adapter, context, statusRetrySignal) {
-        try {
-            await adapter.setAssistantStatus(context.channelId, context.threadTs, SLACK_THINKING_STATUS, [
-                SLACK_THINKING_STATUS,
-            ]);
-            return;
-        }
-        catch (error) {
-            if (getSlackErrorCode(error) !== 'invalid_thread_ts') {
-                this.logger.warn('[AgentChatBridge] Failed to set Slack assistant status', {
-                    agentId: this.agentId,
-                    channelId: context.channelId,
-                    threadTs: context.threadTs,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return;
-            }
-        }
-        if (!(await sleep(SLACK_STATUS_RETRY_DELAY_MS, statusRetrySignal)))
-            return;
-        if (statusRetrySignal?.aborted)
-            return;
-        try {
-            await adapter.setAssistantStatus(context.channelId, context.threadTs, SLACK_THINKING_STATUS, [
-                SLACK_THINKING_STATUS,
-            ]);
-        }
-        catch (error) {
-            const errorCode = getSlackErrorCode(error);
-            const logPayload = {
-                agentId: this.agentId,
-                channelId: context.channelId,
-                threadTs: context.threadTs,
-                error: error instanceof Error ? error.message : String(error),
-                ...(errorCode ? { errorCode } : {}),
-            };
-            if (errorCode === 'invalid_thread_ts') {
-                this.logger.debug('[AgentChatBridge] Slack assistant status unavailable for thread', logPayload);
-                return;
-            }
-            this.logger.warn('[AgentChatBridge] Failed to set Slack assistant status', logPayload);
-        }
-    }
-    getSlackThreadContext(message) {
-        if (this.integration.type !== 'slack')
-            return undefined;
-        const raw = message.raw;
-        if (!(0, utils_1.isRecord)(raw))
-            return undefined;
-        const channelId = stringValue(raw.channel);
-        const channelType = stringValue(raw.channel_type);
-        const realThreadTs = stringValue(raw.thread_ts);
-        const threadTs = realThreadTs ?? stringValue(raw.ts);
-        if (!channelId || !threadTs)
-            return undefined;
-        return {
-            channelId,
-            threadTs,
-            hasRealThreadTs: realThreadTs !== undefined,
-            isDm: channelType === 'im',
-        };
-    }
-    getSlackAssistantStatusAdapter() {
-        const adapter = this.chat.getAdapter('slack');
-        return isSlackAssistantStatusAdapter(adapter) ? adapter : undefined;
-    }
-    async updateLatestMessageContext(threadId, resourceId, thread, options = {}) {
-        if (!this.messageContextStore)
-            return undefined;
-        const integrationConnectionId = (0, integration_tools_1.buildIntegrationConnectionId)(this.integration);
-        const previousContext = await this.getPreviousContext(threadId, integrationConnectionId);
-        const agentUserId = options.agentUserId ?? previousContext?.agentUserId;
-        const context = {
-            integrationConnectionId,
-            platform: this.integration.type,
-            target: {
-                type: 'thread',
-                threadId: thread.id,
-                channelId: thread.channelId,
-            },
-            ...(options.messageId ? { messageId: options.messageId } : {}),
-            ...(options.interactingUserId ? { interactingUserId: options.interactingUserId } : {}),
-            ...(agentUserId ? { agentUserId } : {}),
-            ...(options.subject ? { subject: options.subject } : {}),
-            ...(!options.subject && previousContext?.subject ? { subject: previousContext.subject } : {}),
-            updatedAt: new Date().toISOString(),
-        };
-        try {
-            await this.messageContextStore.setLatest(threadId, resourceId, context);
-            return context;
-        }
-        catch (error) {
-            this.logger.warn('[AgentChatBridge] Failed to update latest message context', {
-                agentId: this.agentId,
-                threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return undefined;
-        }
-    }
     getPlatformAgentContext() {
-        if (this.integration.type !== 'slack')
-            return {};
-        const adapter = this.chat.getAdapter(this.integration.type);
-        if (!(0, utils_1.isRecord)(adapter))
-            return {};
-        const agentUserId = stringValue(adapter.botUserId);
-        return agentUserId ? { agentUserId } : {};
+        return this.integrationImpl?.getPlatformAgentContext?.(this.chat) ?? {};
     }
     prepareInboundText(text, context) {
         const trimmed = text?.trim() ?? '';
-        if (this.integration.type !== 'slack' || !context.agentUserId)
-            return trimmed;
-        return stripSlackSelfMention(trimmed, context.agentUserId);
-    }
-    async getPreviousContext(threadId, integrationConnectionId) {
-        if (!this.messageContextStore)
-            return undefined;
-        try {
-            const previousContext = await this.messageContextStore.getLatest(threadId);
-            if (previousContext?.integrationConnectionId !== integrationConnectionId) {
-                return undefined;
-            }
-            return previousContext;
-        }
-        catch (error) {
-            this.logger.warn('[AgentChatBridge] Failed to read previous message context', {
-                agentId: this.agentId,
-                threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return undefined;
-        }
-    }
-    async resolveMessageSubject(message) {
-        try {
-            return toIntegrationMessageSubject(await message.subject);
-        }
-        catch (error) {
-            this.logger.debug(`[AgentChatBridge] Failed to fetch message subject: ${error instanceof Error ? error.message : String(error)}`);
-            return undefined;
-        }
-    }
-    async handleAction(event) {
-        const { thread } = event;
-        if (!thread) {
-            this.logger.warn('[AgentChatBridge] Thread is not set for event', {
-                threadId: event.threadId,
-                actionId: event.actionId,
-            });
-            return;
-        }
-        const callbackData = await this.resolveCallbackData(event.actionId, event.value, thread);
-        if (!callbackData)
-            return;
-        const parsed = this.parseActionId(callbackData.actionId, callbackData.value);
-        if (!parsed)
-            return;
-        const platformThreadId = this.resolvePlatformThreadId(thread);
-        const threadId = this.toAgentThreadId(platformThreadId);
-        await this.updateLatestMessageContext(threadId.id, event.user.userId, thread, {
-            messageId: event.messageId,
-            interactingUserId: event.user.userId,
-            ...this.getPlatformAgentContext(),
-        });
-        await this.cleanUpBeforeResume(event);
-        await this.executeResume(thread, parsed.runId, parsed.toolCallId, parsed.resumeData);
+        return this.integrationImpl?.prepareInboundText?.(trimmed, context) ?? trimmed;
     }
     async postErrorToThread(thread, error) {
         const message = error instanceof Error ? error.message : 'An unexpected error occurred';
@@ -806,45 +261,4 @@ class AgentChatBridge {
     }
 }
 exports.AgentChatBridge = AgentChatBridge;
-function stripSlackSelfMention(text, userId) {
-    const escapedUserId = escapeRegExp(userId);
-    return text
-        .replace(new RegExp(`(^|\\s)<@!?${escapedUserId}(?:\\|[^>]+)?>`, 'gi'), '$1')
-        .replace(new RegExp(`(^|\\s)@${escapedUserId}\\b`, 'gi'), '$1')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function isSlackAssistantStatusAdapter(value) {
-    return (0, utils_1.isRecord)(value) && typeof value.setAssistantStatus === 'function';
-}
-function stringValue(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function getSlackErrorCode(error) {
-    if (!(0, utils_1.isRecord)(error))
-        return undefined;
-    const data = error.data;
-    if (!(0, utils_1.isRecord)(data))
-        return undefined;
-    return stringValue(data.error);
-}
-async function sleep(ms, signal) {
-    if (signal?.aborted)
-        return false;
-    return await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener('abort', abort);
-            resolve(true);
-        }, ms);
-        const abort = () => {
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', abort);
-            resolve(false);
-        };
-        signal?.addEventListener('abort', abort, { once: true });
-    });
-}
 //# sourceMappingURL=agent-chat-bridge.js.map