n8n 2.23.2 → 2.25.1

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

@@ -5,9 +5,48 @@ const di_1 = require("@n8n/di");
 const agent_memory_scope_1 = require("../utils/agent-memory-scope");
 const agent_chat_integration_1 = require("./agent-chat-integration");
 const callback_store_1 = require("./callback-store");
+const component_mapper_1 = require("./component-mapper");
+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;
+function isIntegrationActionSuspendPayload(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'type' in value &&
+        value.type === 'integration_action');
+}
+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) {
+    constructor(chat, agentId, agentService, componentMapper, logger, n8nProjectId, integration, messageContextStore) {
         this.chat = chat;
         this.agentId = agentId;
         this.agentService = agentService;
@@ -15,6 +54,7 @@ class AgentChatBridge {
         this.logger = logger;
         this.n8nProjectId = n8nProjectId;
         this.integration = integration;
+        this.messageContextStore = messageContextStore;
         this.activeResumedRuns = new Set();
         this.richInteractionInputs = new Map();
         this.integrationImpl = di_1.Container.get(agent_chat_integration_1.ChatIntegrationRegistry).get(integration.type);
@@ -45,7 +85,7 @@ class AgentChatBridge {
                 yield* agentService.resumeForChat(config);
             },
         };
-        return new AgentChatBridge(chat, agentId, agentExecutor, componentMapper, logger, n8nProjectId, integration);
+        return new AgentChatBridge(chat, agentId, agentExecutor, componentMapper, logger, n8nProjectId, integration, di_1.Container.get(integration_message_context_service_1.IntegrationMessageContextService));
     }
     registerHandlers() {
         this.chat.onNewMention(async (thread, message) => {
@@ -102,11 +142,25 @@ class AgentChatBridge {
         };
     }
     async executeAndStream(thread, message) {
-        const text = message.text?.trim();
+        const platformAgentContext = this.getPlatformAgentContext();
+        const text = this.prepareInboundText(message.text, platformAgentContext).trim();
         if (!text)
             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 [, subject] = await Promise.all([
+            this.startThinkingStatus(thread, slackThreadContext, statusRetry.signal),
+            this.resolveMessageSubject(message),
+        ]);
+        await this.updateLatestMessageContext(threadId.id, message.author.userId, thread, {
+            messageId: message.id,
+            interactingUserId: message.author.userId,
+            ...platformAgentContext,
+            subject,
+        });
         const stream = this.agentService.executeForChatPublished({
             agentId: this.agentId,
             projectId: this.n8nProjectId,
@@ -117,10 +171,17 @@ class AgentChatBridge {
             },
             integrationType: this.integration.type,
         });
-        await this.consumeStream(stream, thread);
+        try {
+            await this.consumeStream(stream, thread, {
+                forceBuffered: this.integration.type === 'slack' && !useNativeSlackThreadFeatures,
+            });
+        }
+        finally {
+            statusRetry.abort();
+        }
     }
-    async consumeStream(stream, thread) {
-        if (this.disableStreaming) {
+    async consumeStream(stream, thread, options = {}) {
+        if (this.disableStreaming || options.forceBuffered) {
             await this.consumeStreamBuffered(stream, thread);
             return;
         }
@@ -192,50 +253,55 @@ class AgentChatBridge {
             if (!streamingPost)
                 startStreamingPost();
         };
-        for await (const chunk of stream) {
-            switch (chunk.type) {
-                case 'text-delta': {
-                    const { delta } = chunk;
-                    ensureStreamingPost();
-                    textStream.yield?.(delta);
-                    break;
-                }
-                case 'reasoning-delta': {
-                    const { delta } = chunk;
-                    ensureStreamingPost();
-                    textStream.yield?.(`_${delta}_`);
-                    break;
-                }
-                case 'tool-call':
-                    this.stashRichInteractionInput(chunk);
-                    break;
-                case 'tool-call-suspended':
-                    this.richInteractionInputs.delete(chunk.toolCallId);
-                    await endStreamingPost();
-                    await this.handleSuspension(chunk, thread);
-                    break;
-                case 'tool-result':
-                    if (this.isRichInteractionDisplayOnly(chunk)) {
-                        await endStreamingPost();
-                        await this.handleDisplayOnly(chunk, thread);
+        try {
+            for await (const chunk of stream) {
+                switch (chunk.type) {
+                    case 'text-delta': {
+                        const { delta } = chunk;
+                        ensureStreamingPost();
+                        textStream.yield?.(delta);
+                        break;
                     }
-                    else {
-                        this.richInteractionInputs.delete(chunk.toolCallId);
+                    case 'reasoning-delta': {
+                        const { delta } = chunk;
+                        ensureStreamingPost();
+                        textStream.yield?.(`_${delta}_`);
+                        break;
                     }
-                    break;
-                case 'message':
-                    await endStreamingPost();
-                    await this.handleMessage(chunk, thread);
-                    break;
-                case 'error':
-                    await endStreamingPost();
-                    await this.postErrorToThread(thread, chunk.error);
-                    break;
-                default:
-                    break;
+                    case 'tool-call':
+                        this.stashRichInteractionInput(chunk);
+                        break;
+                    case 'tool-call-suspended':
+                        this.richInteractionInputs.delete(chunk.toolCallId);
+                        await endStreamingPost();
+                        await this.handleSuspension(chunk, thread);
+                        break;
+                    case 'tool-result':
+                        if (this.isRichInteractionDisplayOnly(chunk)) {
+                            await endStreamingPost();
+                            await this.handleDisplayOnly(chunk, thread);
+                        }
+                        else {
+                            this.richInteractionInputs.delete(chunk.toolCallId);
+                        }
+                        break;
+                    case 'message':
+                        await endStreamingPost();
+                        await this.handleMessage(chunk, thread);
+                        break;
+                    case 'error':
+                        await endStreamingPost();
+                        await this.postErrorToThread(thread, chunk.error);
+                        break;
+                    default:
+                        break;
+                }
             }
         }
-        await endStreamingPost();
+        finally {
+            await endStreamingPost();
+            this.richInteractionInputs.clear();
+        }
     }
     async consumeStreamBuffered(stream, thread) {
         let buffer = '';
@@ -254,44 +320,49 @@ class AgentChatBridge {
                 });
             }
         };
-        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':
-                    this.stashRichInteractionInput(chunk);
-                    break;
-                case 'tool-call-suspended':
-                    this.richInteractionInputs.delete(chunk.toolCallId);
-                    await flushBuffer();
-                    await this.handleSuspension(chunk, thread);
-                    break;
-                case 'tool-result':
-                    if (this.isRichInteractionDisplayOnly(chunk)) {
-                        await flushBuffer();
-                        await this.handleDisplayOnly(chunk, thread);
-                    }
-                    else {
+        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':
+                        this.stashRichInteractionInput(chunk);
+                        break;
+                    case 'tool-call-suspended':
                         this.richInteractionInputs.delete(chunk.toolCallId);
-                    }
-                    break;
-                case 'message':
-                    await flushBuffer();
-                    await this.handleMessage(chunk, thread);
-                    break;
-                case 'error':
-                    await flushBuffer();
-                    await this.postErrorToThread(thread, chunk.error);
-                    break;
-                default:
-                    break;
+                        await flushBuffer();
+                        await this.handleSuspension(chunk, thread);
+                        break;
+                    case 'tool-result':
+                        if (this.isRichInteractionDisplayOnly(chunk)) {
+                            await flushBuffer();
+                            await this.handleDisplayOnly(chunk, thread);
+                        }
+                        else {
+                            this.richInteractionInputs.delete(chunk.toolCallId);
+                        }
+                        break;
+                    case 'message':
+                        await flushBuffer();
+                        await this.handleMessage(chunk, thread);
+                        break;
+                    case 'error':
+                        await flushBuffer();
+                        await this.postErrorToThread(thread, chunk.error);
+                        break;
+                    default:
+                        break;
+                }
             }
         }
-        await flushBuffer();
+        finally {
+            await flushBuffer();
+            this.richInteractionInputs.clear();
+        }
     }
     async handleSuspension(chunk, thread) {
         const { runId, toolCallId, suspendPayload } = chunk;
@@ -304,6 +375,9 @@ class AgentChatBridge {
             return;
         }
         const payload = suspendPayload;
+        if (isIntegrationActionSuspendPayload(payload)) {
+            return;
+        }
         const hasComponents = payload &&
             'components' in payload &&
             Array.isArray(payload.components) &&
@@ -344,15 +418,8 @@ class AgentChatBridge {
             this.logger.warn('[AgentChatBridge] rich_interaction has no components');
             return;
         }
-        const riResumeSchema = {
-            type: 'object',
-            properties: {
-                type: { type: 'string' },
-                value: { type: 'string' },
-            },
-        };
         try {
-            const card = await this.componentMapper.toCard(payload, runId, toolCallId, riResumeSchema, this.getShortenCallback(), this.integration.type);
+            const card = await this.componentMapper.toCard(payload, runId, toolCallId, component_mapper_1.RICH_INTERACTION_RESUME_JSON_SCHEMA, this.getShortenCallback(), this.integration.type);
             await thread.post(card);
         }
         catch (error) {
@@ -386,12 +453,8 @@ class AgentChatBridge {
             });
             return;
         }
-        const displayResumeSchema = {
-            type: 'object',
-            properties: { type: { type: 'string' }, value: { type: 'string' } },
-        };
         try {
-            const card = await this.componentMapper.toCard(cardPayload, '', toolCallId, displayResumeSchema, this.getShortenCallback(), this.integration.type);
+            const card = await this.componentMapper.toCard(cardPayload, '', toolCallId, component_mapper_1.RICH_INTERACTION_RESUME_JSON_SCHEMA, this.getShortenCallback(), this.integration.type);
             await thread.post({ card });
         }
         catch (error) {
@@ -422,21 +485,6 @@ class AgentChatBridge {
         }
     }
     parseActionId(actionId, value) {
-        if (actionId.startsWith('ri-btn:')) {
-            const parts = actionId.split(':');
-            if (parts.length < 4) {
-                this.logger.warn('[AgentChatBridge] Malformed ri-btn action ID', { actionId });
-                return null;
-            }
-            let resumeData;
-            try {
-                resumeData = JSON.parse(value ?? '');
-            }
-            catch {
-                resumeData = { type: 'button', value };
-            }
-            return { runId: parts[1], toolCallId: parts.slice(2, -1).join(':'), resumeData };
-        }
         if (actionId.startsWith('ri-sel:')) {
             const parts = actionId.split(':');
             if (parts.length < 4) {
@@ -486,13 +534,6 @@ class AgentChatBridge {
                 error: deleteError instanceof Error ? deleteError.message : String(deleteError),
             });
         }
-        const threadInternal = event.thread;
-        if (threadInternal?._currentMessage?.raw) {
-            const raw = threadInternal._currentMessage.raw;
-            if (raw.team && typeof raw.team === 'object' && !raw.team_id) {
-                raw.team_id = raw.team.id;
-            }
-        }
     }
     async executeResume(thread, runId, toolCallId, resumeData) {
         if (this.activeResumedRuns.has(runId)) {
@@ -502,6 +543,7 @@ class AgentChatBridge {
         }
         this.activeResumedRuns.add(runId);
         try {
+            await this.startThinkingStatus(thread);
             const stream = this.agentService.resumeForChat({
                 agentId: this.agentId,
                 projectId: this.n8nProjectId,
@@ -516,6 +558,169 @@ class AgentChatBridge {
             this.activeResumedRuns.delete(runId);
         }
     }
+    async startThinkingStatus(thread, slackThreadContext, statusRetrySignal) {
+        if (this.integration.type !== 'slack')
+            return;
+        if (slackThreadContext && !slackThreadContext.hasRealThreadTs) {
+            this.setSlackAssistantStatus(slackThreadContext, statusRetrySignal);
+            return;
+        }
+        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),
+            });
+        }
+    }
+    setSlackAssistantStatus(context, statusRetrySignal) {
+        const adapter = this.getSlackAssistantStatusAdapter();
+        if (!adapter)
+            return;
+        void this.setSlackAssistantStatusWithRetry(adapter, context, statusRetrySignal);
+    }
+    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;
+        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 (!isRecord(raw))
+            return undefined;
+        const channelId = stringValue(raw.channel);
+        const realThreadTs = stringValue(raw.thread_ts);
+        const threadTs = realThreadTs ?? stringValue(raw.ts);
+        if (!channelId || !threadTs)
+            return undefined;
+        return {
+            channelId,
+            threadTs,
+            hasRealThreadTs: realThreadTs !== undefined,
+        };
+    }
+    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 (!isRecord(adapter))
+            return {};
+        const agentUserId = stringValue(adapter.botUserId);
+        return agentUserId ? { agentUserId } : {};
+    }
+    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) {
@@ -531,6 +736,13 @@ class AgentChatBridge {
         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);
     }
@@ -560,4 +772,48 @@ 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 isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isSlackAssistantStatusAdapter(value) {
+    return 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 (!isRecord(error))
+        return undefined;
+    const data = error.data;
+    if (!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