The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(slack): answer the assistant request in the execution that records it (#25702)
Abdul Rahman1732736aa637
diff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.jsonindex 0b8009ce522..898d7c08bd3 100644--- a/packages/twenty-apps/public/slack/package.json+++ b/packages/twenty-apps/public/slack/package.json@@ -1,6 +1,6 @@{"name": "@twentyhq/slack",- "version": "1.0.2",+ "version": "1.1.0","description": "Slack assistant and workflow steps for Twenty","license": "MIT","engines": {diff --git a/packages/twenty-apps/public/slack/src/__tests__/slack-assistant-worker.integration-test.ts b/packages/twenty-apps/public/slack/src/__tests__/slack-assistant-worker.integration-test.tsindex d04b1324f3c..83d9f2d1ae8 100644--- a/packages/twenty-apps/public/slack/src/__tests__/slack-assistant-worker.integration-test.ts+++ b/packages/twenty-apps/public/slack/src/__tests__/slack-assistant-worker.integration-test.ts@@ -12,7 +12,7 @@ import { SLACK_ASSISTANT_FEEDBACK_ACTION_ID } from 'src/logic-functions/constantimport { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';import { SLACK_ASSISTANT_INITIAL_STATUS } from 'src/logic-functions/constants/slack-assistant-status-steps';import { SLACK_MARKDOWN_BLOCK_MAX_LENGTH } from 'src/logic-functions/constants/slack-markdown-block-max-length';-import { slackAssistantWorkerHandler } from 'src/logic-functions/slack-assistant-worker';+import { slackAssistantWorkerHandler } from 'src/logic-functions/handlers/slack-assistant-worker-handler';import { getSlackThreadKvKey } from 'src/logic-functions/utils/get-slack-thread-kv-key';const CHANNEL_ID = 'C0WORKERTEST';@@ -30,18 +30,14 @@ type SlackAssistantRequestRecordFields = {errorMessage?: string | null;};-type WorkerEvent = Parameters<typeof slackAssistantWorkerHandler>[0];+type WorkerRecord = Parameters<typeof slackAssistantWorkerHandler>[0];describe('Slack assistant worker', () => {- const { slack, appRuntime, coreClient, workspaceId } =- setupSlackIntegrationTest();+ const { slack, appRuntime, coreClient } = setupSlackIntegrationTest();const createdRequestIds: string[] = [];const nextMessageTimestamp = createSlackMessageTimestampSequence(1);- // Records are stored as PROCESSING so that the deployed worker on the test- // server leaves them alone; the handler under test gets its PENDING record- // from the database event payload, exactly like the real trigger does.const createRequestRecord = async (fields: {slackChannelId: string;slackMessageTimestamp: string;@@ -54,7 +50,7 @@ describe('Slack assistant worker', () => {__args: {data: {name: fields.requestText,- status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,slackChannelType: 'channel',slackThreadTimestamp: '',slackUserId: REQUESTER_USER_ID,@@ -96,9 +92,7 @@ describe('Slack assistant worker', () => {);};- // The worker only reads `properties.after`; the surrounding database event- // metadata is irrelevant to its behavior.- const buildRequestCreatedEvent = (record: {+ const buildPendingRequest = (record: {id: string;slackChannelId: string;slackMessageTimestamp: string;@@ -106,20 +100,13 @@ describe('Slack assistant worker', () => {slackChannelType?: string;slackThreadTimestamp?: string;status?: SlackAssistantRequestStatus;- }): WorkerEvent =>- ({- name: 'slackAssistantRequest.created',- workspaceId,- properties: {- after: {- status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,- slackChannelType: 'channel',- slackThreadTimestamp: '',- slackUserId: REQUESTER_USER_ID,- ...record,- },- },- }) as unknown as WorkerEvent;+ }): WorkerRecord => ({+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ slackChannelType: 'channel',+ slackThreadTimestamp: '',+ slackUserId: REQUESTER_USER_ID,+ ...record,+ });afterEach(async () => {for (const requestId of createdRequestIds) {@@ -154,7 +141,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -170,9 +157,7 @@ describe('Slack assistant worker', () => {expect(promptedRequest).toContain('create a follow-up task for @Bob Lee (membership not confirmed) and tell @unknown Slack user U0GHOST in #general',);- expect(promptedRequest).toContain(- 'Slack mentions in this request',- );+ expect(promptedRequest).toContain('Slack mentions in this request');expect(promptedRequest).not.toContain('<@U0');});@@ -213,7 +198,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -318,7 +303,7 @@ describe('Slack assistant worker', () => {});await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: DIRECT_MESSAGE_CHANNEL_ID,slackChannelType: 'im',@@ -362,7 +347,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -405,7 +390,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -448,7 +433,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -486,7 +471,7 @@ describe('Slack assistant worker', () => {});const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -523,7 +508,7 @@ describe('Slack assistant worker', () => {});await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({...request,slackChannelId: CHANNEL_ID,slackMessageTimestamp,@@ -560,7 +545,7 @@ describe('Slack assistant worker', () => {const slackMessageTimestamp = nextMessageTimestamp();const result = await slackAssistantWorkerHandler(- buildRequestCreatedEvent({+ buildPendingRequest({id: 'not-persisted',status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,slackChannelId: CHANNEL_ID,diff --git a/packages/twenty-apps/public/slack/src/__tests__/slack-inbound-events.integration-test.ts b/packages/twenty-apps/public/slack/src/__tests__/slack-inbound-events.integration-test.tsindex 366e0ed1513..fb2cbd13adf 100644--- a/packages/twenty-apps/public/slack/src/__tests__/slack-inbound-events.integration-test.ts+++ b/packages/twenty-apps/public/slack/src/__tests__/slack-inbound-events.integration-test.ts@@ -10,7 +10,7 @@ import { createSlackMessageTimestampSequence } from 'src/__tests__/utils/create-import { setupSlackIntegrationTest } from 'src/__tests__/utils/setup-slack-integration-test.util';import {SLACK_CHANNEL_WELCOME_UNIVERSAL_IDENTIFIER,- SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,+ SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,SLACK_HOME_OPENED_UNIVERSAL_IDENTIFIER,} from 'src/constants/universal-identifiers';import { SLACK_ASSISTANT_EMPTY_REQUEST_TEXT } from 'src/logic-functions/constants/slack-assistant-empty-request-text';@@ -177,7 +177,7 @@ describe('Slack inbound events', () => {expect.objectContaining({workspaceId,targetLogicFunctionUniversalIdentifier:- SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,+ SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,}),);});@@ -251,7 +251,10 @@ describe('Slack inbound events', () => {}),);- expect(result).toEqual({ ok: true });+ expect(result).toEqual({+ ok: true,+ request: expect.objectContaining({ id: expect.any(String) }),+ });const request = await findRequestByMessageTimestamp(slackMessageTimestamp,@@ -270,7 +273,7 @@ describe('Slack inbound events', () => {);});- it('should ignore a redelivery of the same Slack message', async () => {+ it('should hand a redelivery of an unanswered Slack message back to the same request', async () => {const slackMessageTimestamp = nextMessageTimestamp();const eventBody = buildSlackAppMentionEventBody({channelId: CHANNEL_ID,@@ -279,12 +282,12 @@ describe('Slack inbound events', () => {botUserId: slack.botUserId,});- await enqueueSlackAssistantRequest(eventBody);+ const firstResult = await enqueueSlackAssistantRequest(eventBody);const redeliveryResult = await enqueueSlackAssistantRequest(eventBody);expect(redeliveryResult).toEqual({ok: true,- skipped: 'Slack message is already queued',+ request: expect.objectContaining({ id: firstResult.request?.id }),});await expect(findRequestByMessageTimestamp(slackMessageTimestamp),@@ -400,7 +403,10 @@ describe('Slack inbound events', () => {}),);- expect(result).toEqual({ ok: true });+ expect(result).toEqual({+ ok: true,+ request: expect.objectContaining({ id: expect.any(String) }),+ });const request = await findRequestByMessageTimestamp(slackMessageTimestamp,diff --git a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.tsindex d5dec29b4da..4cbc82a0ab1 100644--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts@@ -34,9 +34,12 @@ export const SLACK_ASSISTANT_ROLE_UNIVERSAL_IDENTIFIER =export const SLACK_EVENTS_ROUTE_UNIVERSAL_IDENTIFIER ='9ad6fa20-dff5-4d3f-ad5f-084f3c8b0b09';-export const SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER =+export const SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER ='8f2e1d3c-4b5a-4c6d-9e7f-0a1b2c3d4e5f';+export const SLACK_ASSISTANT_WORKER_UNIVERSAL_IDENTIFIER =+ '4b92a49f-d674-46ea-a3d9-e8d658ae3a17';+export const SLACK_INTERACTIVITY_ROUTE_UNIVERSAL_IDENTIFIER ='fd756b00-50a2-4816-a919-a1a959a2ed9a';@@ -52,9 +55,6 @@ export const SLACK_CHANNEL_WELCOME_UNIVERSAL_IDENTIFIER =export const SLACK_HOME_OPENED_UNIVERSAL_IDENTIFIER ='0ab0156f-11eb-49d6-bda2-cf078638886c';-export const SLACK_ASSISTANT_WORKER_UNIVERSAL_IDENTIFIER =- '4b92a49f-d674-46ea-a3d9-e8d658ae3a17';-export const SLACK_LINK_UNFURL_UNIVERSAL_IDENTIFIER ='b9126247-b6f3-4c1f-a4c5-1c7b28d4beea';diff --git a/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-request.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-request.test.tsnew file mode 100644index 00000000000..86901f71fef--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-request.test.ts@@ -0,0 +1,93 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { SLACK_ASSISTANT_AGENT_BUDGET_SECONDS } from 'src/logic-functions/constants/slack-assistant-agent-budget-seconds';+import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { slackAssistantRequestHandler } from 'src/logic-functions/slack-assistant-request';+import { type SlackEventsRequestBody } from 'src/logic-functions/types/slack-events-request-body.type';++const { enqueueSlackAssistantRequestMock, slackAssistantWorkerHandlerMock } =+ vi.hoisted(() => ({+ enqueueSlackAssistantRequestMock: vi.fn(),+ slackAssistantWorkerHandlerMock: vi.fn(),+ }));++vi.mock('src/logic-functions/utils/enqueue-slack-assistant-request', () => ({+ enqueueSlackAssistantRequest: enqueueSlackAssistantRequestMock,+}));++vi.mock('src/logic-functions/handlers/slack-assistant-worker-handler', () => ({+ slackAssistantWorkerHandler: slackAssistantWorkerHandlerMock,+}));++const EVENT_BODY: SlackEventsRequestBody = { type: 'event_callback' };++const PENDING_REQUEST = {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ slackChannelId: 'D123',+ slackMessageTimestamp: '1700000000.000100',+ requestText: 'how many open deals does Acme have?',+};++describe('slackAssistantRequestHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ slackAssistantWorkerHandlerMock.mockResolvedValue({ done: true });+ });++ it('should answer the request it just recorded in the same execution', async () => {+ enqueueSlackAssistantRequestMock.mockResolvedValue({+ ok: true,+ request: PENDING_REQUEST,+ });++ const result = await slackAssistantRequestHandler(EVENT_BODY);++ expect(enqueueSlackAssistantRequestMock).toHaveBeenCalledExactlyOnceWith(+ EVENT_BODY,+ );+ expect(slackAssistantWorkerHandlerMock).toHaveBeenCalledExactlyOnceWith(+ PENDING_REQUEST,+ { agentDeadlineAtMs: expect.any(Number) },+ );+ expect(result).toEqual({ done: true });+ });++ it('should count the agent budget from the start of the execution', async () => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date('2026-09-09T12:00:00.000Z'));+ enqueueSlackAssistantRequestMock.mockImplementation(async () => {+ vi.advanceTimersByTime(5_000);++ return { ok: true, request: PENDING_REQUEST };+ });++ await slackAssistantRequestHandler(EVENT_BODY);++ expect(slackAssistantWorkerHandlerMock).toHaveBeenCalledWith(+ PENDING_REQUEST,+ {+ agentDeadlineAtMs:+ new Date('2026-09-09T12:00:00.000Z').getTime() ++ SLACK_ASSISTANT_AGENT_BUDGET_SECONDS * 1000,+ },+ );++ vi.useRealTimers();+ });++ it('should stop at the enqueue result when no request was recorded', async () => {+ enqueueSlackAssistantRequestMock.mockResolvedValue({+ ok: true,+ skipped: 'Slack message is already queued',+ });++ const result = await slackAssistantRequestHandler(EVENT_BODY);++ expect(result).toEqual({+ ok: true,+ skipped: 'Slack message is already queued',+ });+ expect(slackAssistantWorkerHandlerMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-worker.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-worker.test.tsindex 01fc9b5378e..09cd8137e8b 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-worker.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-worker.test.ts@@ -1,241 +1,52 @@import { beforeEach, describe, expect, it, vi } from 'vitest';import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';-import { slackAssistantWorkerHandler } from 'src/logic-functions/slack-assistant-worker';-import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';+import { slackAssistantWorkerDrainHandler } from 'src/logic-functions/slack-assistant-worker';-const {- callLog,- coreApiClientMock,- updateSlackAssistantRequestMock,- fetchSlackAssistantContextMock,- fetchWorkspaceBaseUrlsMock,- resolveSlackRunAsForRequestMock,- runSlackAssistantAgentWithDeadlineMock,- sendSlackMessageMock,- startSlackAssistantStatusUpdatesMock,- stopStatusUpdatesMock,- finishSlackAssistantRequestWithFailureMock,- setSlackAssistantThreadTitleMock,- subscribeSlackThreadMock,-} = vi.hoisted(() => ({- callLog: [] as string[],- coreApiClientMock: vi.fn(),- updateSlackAssistantRequestMock: vi.fn(),- fetchSlackAssistantContextMock: vi.fn(),- fetchWorkspaceBaseUrlsMock: vi.fn(),- resolveSlackRunAsForRequestMock: vi.fn(),- runSlackAssistantAgentWithDeadlineMock: vi.fn(),- sendSlackMessageMock: vi.fn(),- startSlackAssistantStatusUpdatesMock: vi.fn(),- stopStatusUpdatesMock: vi.fn(),- finishSlackAssistantRequestWithFailureMock: vi.fn(),- setSlackAssistantThreadTitleMock: vi.fn(),- subscribeSlackThreadMock: vi.fn(),+const { slackAssistantWorkerHandlerMock } = vi.hoisted(() => ({+ slackAssistantWorkerHandlerMock: vi.fn(),}));-vi.mock('twenty-client-sdk/core', () => ({- CoreApiClient: coreApiClientMock,+vi.mock('src/logic-functions/handlers/slack-assistant-worker-handler', () => ({+ slackAssistantWorkerHandler: slackAssistantWorkerHandlerMock,}));-vi.mock('src/logic-functions/data/update-slack-assistant-request', () => ({- updateSlackAssistantRequest: updateSlackAssistantRequestMock,-}));--vi.mock('src/logic-functions/utils/fetch-slack-assistant-context', () => ({- fetchSlackAssistantContext: fetchSlackAssistantContextMock,-}));--vi.mock('src/logic-functions/utils/fetch-workspace-base-urls', () => ({- fetchWorkspaceBaseUrls: fetchWorkspaceBaseUrlsMock,-}));--vi.mock('src/logic-functions/utils/resolve-slack-run-as-for-request', () => ({- resolveSlackRunAsForRequest: resolveSlackRunAsForRequestMock,-}));--vi.mock(- 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline',- () => ({- runSlackAssistantAgentWithDeadline: runSlackAssistantAgentWithDeadlineMock,- }),-);--vi.mock('src/logic-functions/utils/send-slack-message', () => ({- sendSlackMessage: sendSlackMessageMock,-}));--vi.mock(- 'src/logic-functions/utils/start-slack-assistant-status-updates',- () => ({- startSlackAssistantStatusUpdates: startSlackAssistantStatusUpdatesMock,- }),-);--vi.mock(- 'src/logic-functions/utils/finish-slack-assistant-request-with-failure',- () => ({- finishSlackAssistantRequestWithFailure:- finishSlackAssistantRequestWithFailureMock,- }),-);--vi.mock('src/logic-functions/utils/set-slack-assistant-thread-title', () => ({- setSlackAssistantThreadTitle: setSlackAssistantThreadTitleMock,-}));--vi.mock('src/logic-functions/utils/subscribe-slack-thread', () => ({- subscribeSlackThread: subscribeSlackThreadMock,-}));+type SlackAssistantRequestCreatedEvent = Parameters<+ typeof slackAssistantWorkerDrainHandler+>[0];-const REQUEST_RECORD: SlackAssistantRequestRecord = {+const PENDING_REQUEST = {id: 'request-1',status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,slackChannelId: 'D123',- slackChannelType: 'im',- slackThreadTimestamp: '',slackMessageTimestamp: '1700000000.000100',- slackUserId: 'U123',requestText: 'how many open deals does Acme have?',};-const SLACK_CONTEXT = {- conversationMessages: [],- requesterName: 'Ada',- requesterIdentity: undefined,- requestMessage: undefined,- threadMessages: [],- slackClient: undefined,- assistantBotUserId: undefined,- isDirectMessage: true,-};--type SlackAssistantRequestCreatedEvent = Parameters<- typeof slackAssistantWorkerHandler->[0];--const buildEvent = (- record: SlackAssistantRequestRecord = REQUEST_RECORD,-): SlackAssistantRequestCreatedEvent =>- ({- name: 'slackAssistantRequest.created',- workspaceId: 'workspace-1',- objectMetadata: { nameSingular: 'slackAssistantRequest' },- properties: { after: record },- }) as SlackAssistantRequestCreatedEvent;--describe('slackAssistantWorkerHandler', () => {+describe('slackAssistantWorkerDrainHandler', () => {beforeEach(() => {vi.clearAllMocks();- callLog.length = 0;-- coreApiClientMock.mockImplementation(function () {- return {};- });- updateSlackAssistantRequestMock.mockResolvedValue(undefined);- fetchWorkspaceBaseUrlsMock.mockResolvedValue(['https://acme.twenty.com']);- resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);- setSlackAssistantThreadTitleMock.mockResolvedValue(undefined);- subscribeSlackThreadMock.mockResolvedValue(undefined);-- startSlackAssistantStatusUpdatesMock.mockImplementation(() => {- callLog.push('status:start');-- return stopStatusUpdatesMock;- });- stopStatusUpdatesMock.mockImplementation(async () => {- callLog.push('status:stop');- });- fetchSlackAssistantContextMock.mockImplementation(async () => {- callLog.push('context:fetch');-- return SLACK_CONTEXT;- });- runSlackAssistantAgentWithDeadlineMock.mockImplementation(async () => {- callLog.push('agent:run');-- return { success: true, error: null, result: { response: 'Two.' } };- });- sendSlackMessageMock.mockImplementation(async () => {- callLog.push('reply:answer');-- return { success: true, slackTs: '1700000000.000200' };- });- finishSlackAssistantRequestWithFailureMock.mockImplementation(- async ({ errorMessage }: { errorMessage: string }) => {- callLog.push('reply:failure');-- return { failed: true, reason: errorMessage };- },- );- });-- it('should show the thinking status before fetching the Slack context', async () => {- await slackAssistantWorkerHandler(buildEvent());-- expect(callLog).toEqual([- 'status:start',- 'context:fetch',- 'agent:run',- 'status:stop',- 'reply:answer',- ]);- expect(- startSlackAssistantStatusUpdatesMock,- ).toHaveBeenCalledExactlyOnceWith({- slackChannelId: REQUEST_RECORD.slackChannelId,- threadTimestamp: REQUEST_RECORD.slackMessageTimestamp,- });});- it('should stop the status before the failure reply when the context lookup throws', async () => {- fetchSlackAssistantContextMock.mockImplementation(async () => {- callLog.push('context:fetch');-- throw new Error('Slack is unreachable');+ it('should hand the created record to the claim-based worker', async () => {+ slackAssistantWorkerHandlerMock.mockResolvedValue({+ skipped: true,+ reason: 'Request is already being processed',});- const result = await slackAssistantWorkerHandler(buildEvent());+ const result = await slackAssistantWorkerDrainHandler({+ name: 'slackAssistantRequest.created',+ workspaceId: 'workspace-1',+ objectMetadata: { nameSingular: 'slackAssistantRequest' },+ properties: { after: PENDING_REQUEST },+ } as SlackAssistantRequestCreatedEvent);- expect(result).toEqual({ failed: true, reason: 'Slack is unreachable' });- expect(callLog).toEqual([- 'status:start',- 'context:fetch',- 'status:stop',- 'reply:failure',- ]);- expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();- });-- it('should stop the status before the failure reply when the agent fails', async () => {- runSlackAssistantAgentWithDeadlineMock.mockImplementation(async () => {- callLog.push('agent:run');-- return { success: false, error: 'Agent crashed', result: null };- });-- const result = await slackAssistantWorkerHandler(buildEvent());-- expect(result).toEqual({ failed: true, reason: 'Agent crashed' });- expect(callLog).toEqual([- 'status:start',- 'context:fetch',- 'agent:run',- 'status:stop',- 'reply:failure',- ]);- expect(stopStatusUpdatesMock).toHaveBeenCalledOnce();- });-- it('should not start the status for a request that is no longer pending', async () => {- const result = await slackAssistantWorkerHandler(- buildEvent({- ...REQUEST_RECORD,- status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,- }),+ expect(slackAssistantWorkerHandlerMock).toHaveBeenCalledExactlyOnceWith(+ PENDING_REQUEST,);-- expect(result).toEqual({ skipped: true, reason: 'Request is not pending' });- expect(startSlackAssistantStatusUpdatesMock).not.toHaveBeenCalled();+ expect(result).toEqual({+ skipped: true,+ reason: 'Request is already being processed',+ });});});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-events-resolver.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-events-resolver.test.tsindex b64f11bc735..bc16e871121 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-events-resolver.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-events-resolver.test.ts@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';import {SLACK_ENTITY_DETAILS_UNIVERSAL_IDENTIFIER,- SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,+ SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,SLACK_INSTALL_REVOKED_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,SLACK_LINK_UNFURL_UNIVERSAL_IDENTIFIER,} from 'src/constants/universal-identifiers';@@ -220,7 +220,7 @@ describe('slackEventsResolverHandler', () => {expect(result).toMatchObject({targetLogicFunctionUniversalIdentifier:- SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,+ SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,});expect(findClaimedWorkspaceMock).not.toHaveBeenCalled();});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-agent-budget-seconds.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-agent-budget-seconds.tsindex 82c40e2cc51..bdbfeddd046 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-agent-budget-seconds.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-agent-budget-seconds.ts@@ -1,6 +1,6 @@import { SLACK_ASSISTANT_FAILURE_REPLY_RESERVE_SECONDS } from 'src/logic-functions/constants/slack-assistant-failure-reply-reserve-seconds';-import { SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-worker-timeout-seconds';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';export const SLACK_ASSISTANT_AGENT_BUDGET_SECONDS =- SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS -+ SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS -SLACK_ASSISTANT_FAILURE_REPLY_RESERVE_SECONDS;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-request-timeout-seconds.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-request-timeout-seconds.tsnew file mode 100644index 00000000000..5222244151f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-request-timeout-seconds.ts@@ -0,0 +1 @@+export const SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS = 60 * 4;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-worker-timeout-seconds.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-worker-timeout-seconds.tsdeleted file mode 100644index a0b1a619dac..00000000000--- a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-worker-timeout-seconds.ts+++ /dev/null@@ -1 +0,0 @@-export const SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS = 60 * 4;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/claim-slack-assistant-request.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/claim-slack-assistant-request.tsnew file mode 100644index 00000000000..de1401e1ef2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/claim-slack-assistant-request.ts@@ -0,0 +1,37 @@+import { isNonEmptyArray } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { getSlackAssistantRequestLeaseCutoff } from 'src/logic-functions/utils/get-slack-assistant-request-lease-cutoff';++export const claimSlackAssistantRequest = async (+ client: CoreApiClient,+ { id }: { id: string },+): Promise<boolean> => {+ const mutationResult = await client.mutation({+ updateSlackAssistantRequests: {+ __args: {+ data: { status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING },+ filter: {+ and: [+ { id: { eq: id } },+ {+ or: [+ { status: { eq: SLACK_ASSISTANT_REQUEST_STATUS.PENDING } },+ {+ status: { eq: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING },+ updatedAt: {+ lt: getSlackAssistantRequestLeaseCutoff().toISOString(),+ },+ },+ ],+ },+ ],+ },+ },+ id: true,+ },+ });++ return isNonEmptyArray(mutationResult.updateSlackAssistantRequests);+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-assistant-request-by-slack-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-assistant-request-by-slack-message.tsindex f90a6ca87ee..814f2178192 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-assistant-request-by-slack-message.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-assistant-request-by-slack-message.ts@@ -1,12 +1,14 @@import { type CoreApiClient } from 'twenty-client-sdk/core';+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';+export const findSlackAssistantRequestBySlackMessage = async (client: CoreApiClient,{slackChannelId,slackMessageTimestamp,}: { slackChannelId: string; slackMessageTimestamp: string },-): Promise<string | undefined> => {+): Promise<SlackAssistantRequestRecord | undefined> => {const queryResult = await client.query({slackAssistantRequests: {__args: {@@ -16,9 +18,21 @@ export const findSlackAssistantRequestBySlackMessage = async (},first: 1,},- edges: { node: { id: true } },+ edges: {+ node: {+ id: true,+ status: true,+ slackChannelId: true,+ slackChannelType: true,+ slackThreadTimestamp: true,+ slackMessageTimestamp: true,+ slackUserId: true,+ requestText: true,+ updatedAt: true,+ },+ },},});- return queryResult.slackAssistantRequests?.edges?.[0]?.node?.id ?? undefined;+ return queryResult.slackAssistantRequests?.edges?.[0]?.node ?? undefined;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.tsnew file mode 100644index 00000000000..93d8a9a6a14--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.ts@@ -0,0 +1,284 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';+import { slackAssistantWorkerHandler } from 'src/logic-functions/handlers/slack-assistant-worker-handler';+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';++const {+ callLog,+ coreApiClientMock,+ claimSlackAssistantRequestMock,+ updateSlackAssistantRequestMock,+ fetchSlackAssistantContextMock,+ fetchWorkspaceBaseUrlsMock,+ resolveSlackRunAsForRequestMock,+ runSlackAssistantAgentWithDeadlineMock,+ sendSlackMessageMock,+ startSlackAssistantStatusUpdatesMock,+ stopStatusUpdatesMock,+ finishSlackAssistantRequestWithFailureMock,+ setSlackAssistantThreadTitleMock,+ subscribeSlackThreadMock,+} = vi.hoisted(() => ({+ callLog: [] as string[],+ coreApiClientMock: vi.fn(),+ claimSlackAssistantRequestMock: vi.fn(),+ updateSlackAssistantRequestMock: vi.fn(),+ fetchSlackAssistantContextMock: vi.fn(),+ fetchWorkspaceBaseUrlsMock: vi.fn(),+ resolveSlackRunAsForRequestMock: vi.fn(),+ runSlackAssistantAgentWithDeadlineMock: vi.fn(),+ sendSlackMessageMock: vi.fn(),+ startSlackAssistantStatusUpdatesMock: vi.fn(),+ stopStatusUpdatesMock: vi.fn(),+ finishSlackAssistantRequestWithFailureMock: vi.fn(),+ setSlackAssistantThreadTitleMock: vi.fn(),+ subscribeSlackThreadMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/claim-slack-assistant-request', () => ({+ claimSlackAssistantRequest: claimSlackAssistantRequestMock,+}));++vi.mock('src/logic-functions/data/update-slack-assistant-request', () => ({+ updateSlackAssistantRequest: updateSlackAssistantRequestMock,+}));++vi.mock('src/logic-functions/utils/fetch-slack-assistant-context', () => ({+ fetchSlackAssistantContext: fetchSlackAssistantContextMock,+}));++vi.mock('src/logic-functions/utils/fetch-workspace-base-urls', () => ({+ fetchWorkspaceBaseUrls: fetchWorkspaceBaseUrlsMock,+}));++vi.mock('src/logic-functions/utils/resolve-slack-run-as-for-request', () => ({+ resolveSlackRunAsForRequest: resolveSlackRunAsForRequestMock,+}));++vi.mock(+ 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline',+ () => ({+ runSlackAssistantAgentWithDeadline: runSlackAssistantAgentWithDeadlineMock,+ }),+);++vi.mock('src/logic-functions/utils/send-slack-message', () => ({+ sendSlackMessage: sendSlackMessageMock,+}));++vi.mock(+ 'src/logic-functions/utils/start-slack-assistant-status-updates',+ () => ({+ startSlackAssistantStatusUpdates: startSlackAssistantStatusUpdatesMock,+ }),+);++vi.mock(+ 'src/logic-functions/utils/finish-slack-assistant-request-with-failure',+ () => ({+ finishSlackAssistantRequestWithFailure:+ finishSlackAssistantRequestWithFailureMock,+ }),+);++vi.mock('src/logic-functions/utils/set-slack-assistant-thread-title', () => ({+ setSlackAssistantThreadTitle: setSlackAssistantThreadTitleMock,+}));++vi.mock('src/logic-functions/utils/subscribe-slack-thread', () => ({+ subscribeSlackThread: subscribeSlackThreadMock,+}));++const REQUEST_RECORD: SlackAssistantRequestRecord = {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ slackChannelId: 'D123',+ slackChannelType: 'im',+ slackThreadTimestamp: '',+ slackMessageTimestamp: '1700000000.000100',+ slackUserId: 'U123',+ requestText: 'how many open deals does Acme have?',+};++const SLACK_CONTEXT = {+ conversationMessages: [],+ requesterName: 'Ada',+ requesterIdentity: undefined,+ requestMessage: undefined,+ threadMessages: [],+ slackClient: undefined,+ assistantBotUserId: undefined,+ isDirectMessage: true,+};++describe('slackAssistantWorkerHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ callLog.length = 0;++ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ claimSlackAssistantRequestMock.mockResolvedValue(true);+ updateSlackAssistantRequestMock.mockResolvedValue(undefined);+ fetchWorkspaceBaseUrlsMock.mockResolvedValue(['https://acme.twenty.com']);+ resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);+ setSlackAssistantThreadTitleMock.mockResolvedValue(undefined);+ subscribeSlackThreadMock.mockResolvedValue(undefined);++ startSlackAssistantStatusUpdatesMock.mockImplementation(() => {+ callLog.push('status:start');++ return stopStatusUpdatesMock;+ });+ stopStatusUpdatesMock.mockImplementation(async () => {+ callLog.push('status:stop');+ });+ fetchSlackAssistantContextMock.mockImplementation(async () => {+ callLog.push('context:fetch');++ return SLACK_CONTEXT;+ });+ runSlackAssistantAgentWithDeadlineMock.mockImplementation(async () => {+ callLog.push('agent:run');++ return { success: true, error: null, result: { response: 'Two.' } };+ });+ sendSlackMessageMock.mockImplementation(async () => {+ callLog.push('reply:answer');++ return { success: true, slackTs: '1700000000.000200' };+ });+ finishSlackAssistantRequestWithFailureMock.mockImplementation(+ async ({ errorMessage }: { errorMessage: string }) => {+ callLog.push('reply:failure');++ return { failed: true, reason: errorMessage };+ },+ );+ });++ it('should show the thinking status before fetching the Slack context', async () => {+ await slackAssistantWorkerHandler(REQUEST_RECORD);++ expect(callLog).toEqual([+ 'status:start',+ 'context:fetch',+ 'agent:run',+ 'status:stop',+ 'reply:answer',+ ]);+ expect(+ startSlackAssistantStatusUpdatesMock,+ ).toHaveBeenCalledExactlyOnceWith({+ slackChannelId: REQUEST_RECORD.slackChannelId,+ threadTimestamp: REQUEST_RECORD.slackMessageTimestamp,+ });+ });++ it('should stop the status before the failure reply when the context lookup throws', async () => {+ fetchSlackAssistantContextMock.mockImplementation(async () => {+ callLog.push('context:fetch');++ throw new Error('Slack is unreachable');+ });++ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);++ expect(result).toEqual({ failed: true, reason: 'Slack is unreachable' });+ expect(callLog).toEqual([+ 'status:start',+ 'context:fetch',+ 'status:stop',+ 'reply:failure',+ ]);+ expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();+ });++ it('should stop the status before the failure reply when the agent fails', async () => {+ runSlackAssistantAgentWithDeadlineMock.mockImplementation(async () => {+ callLog.push('agent:run');++ return { success: false, error: 'Agent crashed', result: null };+ });++ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);++ expect(result).toEqual({ failed: true, reason: 'Agent crashed' });+ expect(callLog).toEqual([+ 'status:start',+ 'context:fetch',+ 'agent:run',+ 'status:stop',+ 'reply:failure',+ ]);+ expect(stopStatusUpdatesMock).toHaveBeenCalledOnce();+ });++ it('should run the agent against the deadline it was handed', async () => {+ const agentDeadlineAtMs = Date.now() + 60_000;++ await slackAssistantWorkerHandler(REQUEST_RECORD, { agentDeadlineAtMs });++ expect(runSlackAssistantAgentWithDeadlineMock).toHaveBeenCalledWith(+ expect.objectContaining({ deadlineAtMs: agentDeadlineAtMs }),+ );+ });++ it('should leave a request another execution already claimed alone', async () => {+ claimSlackAssistantRequestMock.mockResolvedValue(false);++ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);++ expect(result).toEqual({+ skipped: true,+ reason: 'Request is already being processed',+ });+ expect(callLog).toEqual([]);+ expect(fetchSlackAssistantContextMock).not.toHaveBeenCalled();+ });++ it('should take over a request whose execution died mid-answer', async () => {+ const result = await slackAssistantWorkerHandler({+ ...REQUEST_RECORD,+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date(+ Date.now() - (SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS + 1) * 1000,+ ).toISOString(),+ });++ expect(result).toEqual({ done: true });+ expect(claimSlackAssistantRequestMock).toHaveBeenCalledExactlyOnceWith(+ expect.anything(),+ { id: REQUEST_RECORD.id },+ );+ });++ it('should leave a request whose execution can still be alive alone', async () => {+ const result = await slackAssistantWorkerHandler({+ ...REQUEST_RECORD,+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date().toISOString(),+ });++ expect(result).toEqual({ skipped: true, reason: 'Request is not pending' });+ expect(claimSlackAssistantRequestMock).not.toHaveBeenCalled();+ });++ it('should not start the status for a request that is no longer pending', async () => {+ const result = await slackAssistantWorkerHandler({+ ...REQUEST_RECORD,+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,+ });++ expect(result).toEqual({ skipped: true, reason: 'Request is not pending' });+ expect(claimSlackAssistantRequestMock).not.toHaveBeenCalled();+ expect(startSlackAssistantStatusUpdatesMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.tsnew file mode 100644index 00000000000..3a49fc84b44--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.ts@@ -0,0 +1,237 @@+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { SLACK_ASSISTANT_AGENT_BUDGET_SECONDS } from 'src/logic-functions/constants/slack-assistant-agent-budget-seconds';+import { SLACK_ASSISTANT_EMPTY_RESPONSE_ERROR } from 'src/logic-functions/constants/slack-assistant-empty-response-error';+import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { claimSlackAssistantRequest } from 'src/logic-functions/data/claim-slack-assistant-request';+import { updateSlackAssistantRequest } from 'src/logic-functions/data/update-slack-assistant-request';+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';+import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';+import { buildSlackAssistantAnswerBlocks } from 'src/logic-functions/utils/build-slack-assistant-answer-blocks';+import { buildSlackAssistantMessages } from 'src/logic-functions/utils/build-slack-assistant-messages';+import { buildSlackAnswerDeliveryFailureMessage } from 'src/logic-functions/utils/build-slack-answer-delivery-failure-message';+import { buildSlackAssistantRequestName } from 'src/logic-functions/utils/build-slack-assistant-request-name';+import { enqueueSlackMessageDelivery } from 'src/logic-functions/utils/enqueue-slack-message-delivery';+import { extractAgentResponseText } from 'src/logic-functions/utils/extract-agent-response-text';+import { fetchSlackAssistantContext } from 'src/logic-functions/utils/fetch-slack-assistant-context';+import { fetchWorkspaceBaseUrls } from 'src/logic-functions/utils/fetch-workspace-base-urls';+import { isSlackAssistantRequestResumable } from 'src/logic-functions/utils/is-slack-assistant-request-resumable';+import { finishSlackAssistantRequestWithFailure } from 'src/logic-functions/utils/finish-slack-assistant-request-with-failure';+import { getSlackAssistantParentMessageTimestamp } from 'src/logic-functions/utils/get-slack-assistant-parent-message-timestamp';+import { resolveSlackAssistantMentions } from 'src/logic-functions/utils/resolve-slack-assistant-mentions';+import { resolveSlackRunAsForRequest } from 'src/logic-functions/utils/resolve-slack-run-as-for-request';+import { runSlackAssistantAgentWithDeadline } from 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline';+import { sendSlackMessage } from 'src/logic-functions/utils/send-slack-message';+import { setSlackAssistantThreadTitle } from 'src/logic-functions/utils/set-slack-assistant-thread-title';+import { startSlackAssistantStatusUpdates } from 'src/logic-functions/utils/start-slack-assistant-status-updates';+import { subscribeSlackThread } from 'src/logic-functions/utils/subscribe-slack-thread';++export const slackAssistantWorkerHandler = async (+ record: SlackAssistantRequestRecord,+ {+ agentDeadlineAtMs = Date.now() ++ SLACK_ASSISTANT_AGENT_BUDGET_SECONDS * 1000,+ }: { agentDeadlineAtMs?: number } = {},+): Promise<object> => {+ if (!isSlackAssistantRequestResumable(record)) {+ return { skipped: true, reason: 'Request is not pending' };+ }++ const { slackChannelId, slackMessageTimestamp, requestText } = record;++ if (+ !isNonEmptyString(slackChannelId) ||+ !isNonEmptyString(slackMessageTimestamp) ||+ !isNonEmptyString(requestText)+ ) {+ return { skipped: true, reason: 'Request record is missing fields' };+ }++ const client = new CoreApiClient();++ const isClaimed = await claimSlackAssistantRequest(client, { id: record.id });++ if (!isClaimed) {+ return { skipped: true, reason: 'Request is already being processed' };+ }++ const isThreadStartingMessage = !isNonEmptyString(+ record.slackThreadTimestamp,+ );++ const parentMessageTimestamp = getSlackAssistantParentMessageTimestamp({+ slackThreadTimestamp: record.slackThreadTimestamp,+ slackMessageTimestamp,+ });++ const failureContext = {+ client,+ requestId: record.id,+ slackChannelId,+ parentMessageTimestamp,+ };++ const stopStatusUpdates = startSlackAssistantStatusUpdates({+ slackChannelId,+ threadTimestamp: parentMessageTimestamp,+ });++ try {+ const [+ {+ conversationMessages,+ requesterName,+ requesterIdentity,+ requestMessage,+ threadMessages,+ slackClient,+ assistantBotUserId,+ isDirectMessage,+ },+ workspaceBaseUrls,+ ] = await Promise.all([+ fetchSlackAssistantContext({+ slackChannelId,+ parentMessageTimestamp,+ slackMessageTimestamp,+ slackUserId: record.slackUserId,+ }),+ fetchWorkspaceBaseUrls(),+ ]);++ const runAsWorkspaceMemberId = await resolveSlackRunAsForRequest({+ client,+ slackClient,+ assistantBotUserId,+ identity: requesterIdentity,+ requestId: record.id,+ requestText,+ requestMessage,+ threadMessages,+ isDirectMessage,+ });++ if (isNonEmptyString(runAsWorkspaceMemberId)) {+ await updateSlackAssistantRequest(client, {+ id: record.id,+ workspaceMemberId: runAsWorkspaceMemberId,+ }).catch(() => undefined);+ }++ const resolvedMentions = await resolveSlackAssistantMentions({+ requestText,+ conversationMessages,+ client,+ slackClient,+ assistantBotUserId,+ });++ const agentBudgetRemainingSeconds = Math.max(+ Math.ceil((agentDeadlineAtMs - Date.now()) / 1000),+ 0,+ );++ const agentResult = await runSlackAssistantAgentWithDeadline({+ agentUniversalIdentifier: SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,+ runAsWorkspaceMemberId,+ messages: buildSlackAssistantMessages({+ requestText: resolvedMentions.requestText,+ requesterName,+ conversationMessages: resolvedMentions.conversationMessages,+ runAsWorkspaceMemberId,+ timeoutSeconds: agentBudgetRemainingSeconds,+ workspaceBaseUrl: workspaceBaseUrls[0],+ hasMentionedUsers: resolvedMentions.hasMentionedUsers,+ }),+ deadlineAtMs: agentDeadlineAtMs,+ }).finally(() => stopStatusUpdates());++ if (!agentResult.success) {+ return await finishSlackAssistantRequestWithFailure({+ ...failureContext,+ errorMessage: agentResult.error ?? 'Agent execution failed',+ });+ }++ const responseText = extractAgentResponseText(agentResult);++ if (responseText === undefined) {+ return await finishSlackAssistantRequestWithFailure({+ ...failureContext,+ errorMessage: SLACK_ASSISTANT_EMPTY_RESPONSE_ERROR,+ });+ }++ const answerMessage: SlackPostMessageInput = {+ slackChannelId,+ messageText: responseText,+ parentMessageTimestamp,+ messageFormat: 'markdown',+ unfurlLinks: false,+ unfurlMedia: false,+ messageBlocks: buildSlackAssistantAnswerBlocks({+ responseText,+ requestId: record.id,+ workspaceBaseUrl: workspaceBaseUrls[0],+ }),+ };++ const deliveryResult = await sendSlackMessage(answerMessage, {+ waitOutRateLimit: false,+ });++ const deferredRetryAfterSeconds = deliveryResult.success+ ? undefined+ : deliveryResult.retryAfterSeconds;++ if (!deliveryResult.success && !isDefined(deferredRetryAfterSeconds)) {+ return await finishSlackAssistantRequestWithFailure({+ ...failureContext,+ errorMessage: buildSlackAnswerDeliveryFailureMessage(deliveryResult),+ });+ }++ if (isDefined(deferredRetryAfterSeconds)) {+ await enqueueSlackMessageDelivery({+ payload: { ...answerMessage, slackAssistantRequestId: record.id },+ retryAfterSeconds: deferredRetryAfterSeconds,+ });+ } else {+ await updateSlackAssistantRequest(client, {+ id: record.id,+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,+ responseText,+ });+ }++ if (isDirectMessage) {+ if (isThreadStartingMessage) {+ await setSlackAssistantThreadTitle({+ slackChannelId,+ threadTimestamp: parentMessageTimestamp,+ title: buildSlackAssistantRequestName(requestText),+ });+ }+ } else {+ await subscribeSlackThread({+ channelId: slackChannelId,+ threadTimestamp: parentMessageTimestamp,+ }).catch(() => undefined);+ }++ return isDefined(deferredRetryAfterSeconds)+ ? { deferred: true }+ : { done: true };+ } catch (error) {+ await stopStatusUpdates();++ return await finishSlackAssistantRequestWithFailure({+ ...failureContext,+ errorMessage:+ error instanceof Error ? error.message : 'Unexpected worker error',+ });+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-request.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-request.tsnew file mode 100644index 00000000000..c194350135e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-request.ts@@ -0,0 +1,35 @@+import { defineLogicFunction } from 'twenty-sdk/define';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { SLACK_ASSISTANT_AGENT_BUDGET_SECONDS } from 'src/logic-functions/constants/slack-assistant-agent-budget-seconds';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';+import { slackAssistantWorkerHandler } from 'src/logic-functions/handlers/slack-assistant-worker-handler';+import { type SlackEventsRequestBody } from 'src/logic-functions/types/slack-events-request-body.type';+import { enqueueSlackAssistantRequest } from 'src/logic-functions/utils/enqueue-slack-assistant-request';++export const slackAssistantRequestHandler = async (+ body: SlackEventsRequestBody,+): Promise<object> => {+ const agentDeadlineAtMs =+ Date.now() + SLACK_ASSISTANT_AGENT_BUDGET_SECONDS * 1000;++ const enqueueResult = await enqueueSlackAssistantRequest(body);++ if (!isDefined(enqueueResult.request)) {+ return enqueueResult;+ }++ return await slackAssistantWorkerHandler(enqueueResult.request, {+ agentDeadlineAtMs,+ });+};++export default defineLogicFunction({+ universalIdentifier: SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,+ name: 'slack-assistant-request',+ description:+ 'Runs in the resolved workspace: records the Slack message as a Slack Assistant Request, then answers it in the same execution by showing a native thinking status on the conversation thread, running the Slack Assistant agent against the workspace, and posting the answer as a threaded reply.',+ timeoutSeconds: SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS,+ handler: slackAssistantRequestHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-worker.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-worker.tsindex f45b85f9efb..3a7903d21b9 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-worker.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-assistant-worker.ts@@ -1,260 +1,33 @@-import { isNonEmptyString } from '@sniptt/guards';-import { CoreApiClient } from 'twenty-client-sdk/core';import {type DatabaseEventPayload,defineLogicFunction,type ObjectRecordCreateEvent,} from 'twenty-sdk/define';-import { isDefined } from 'twenty-sdk/utils';-import {- SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,- SLACK_ASSISTANT_WORKER_UNIVERSAL_IDENTIFIER,-} from 'src/constants/universal-identifiers';-import { SLACK_ASSISTANT_AGENT_BUDGET_SECONDS } from 'src/logic-functions/constants/slack-assistant-agent-budget-seconds';-import { SLACK_ASSISTANT_EMPTY_RESPONSE_ERROR } from 'src/logic-functions/constants/slack-assistant-empty-response-error';+import { SLACK_ASSISTANT_WORKER_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';import { SLACK_ASSISTANT_REQUEST_OBJECT_NAME } from 'src/logic-functions/constants/slack-assistant-request-object-name';-import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';-import { SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-worker-timeout-seconds';-import { updateSlackAssistantRequest } from 'src/logic-functions/data/update-slack-assistant-request';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';+import { slackAssistantWorkerHandler } from 'src/logic-functions/handlers/slack-assistant-worker-handler';import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';-import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';-import { buildSlackAssistantAnswerBlocks } from 'src/logic-functions/utils/build-slack-assistant-answer-blocks';-import { buildSlackAssistantMessages } from 'src/logic-functions/utils/build-slack-assistant-messages';-import { buildSlackAnswerDeliveryFailureMessage } from 'src/logic-functions/utils/build-slack-answer-delivery-failure-message';-import { buildSlackAssistantRequestName } from 'src/logic-functions/utils/build-slack-assistant-request-name';-import { enqueueSlackMessageDelivery } from 'src/logic-functions/utils/enqueue-slack-message-delivery';-import { extractAgentResponseText } from 'src/logic-functions/utils/extract-agent-response-text';-import { fetchSlackAssistantContext } from 'src/logic-functions/utils/fetch-slack-assistant-context';-import { fetchWorkspaceBaseUrls } from 'src/logic-functions/utils/fetch-workspace-base-urls';-import { finishSlackAssistantRequestWithFailure } from 'src/logic-functions/utils/finish-slack-assistant-request-with-failure';-import { getSlackAssistantParentMessageTimestamp } from 'src/logic-functions/utils/get-slack-assistant-parent-message-timestamp';-import { resolveSlackAssistantMentions } from 'src/logic-functions/utils/resolve-slack-assistant-mentions';-import { resolveSlackRunAsForRequest } from 'src/logic-functions/utils/resolve-slack-run-as-for-request';-import { runSlackAssistantAgentWithDeadline } from 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline';-import { sendSlackMessage } from 'src/logic-functions/utils/send-slack-message';-import { setSlackAssistantThreadTitle } from 'src/logic-functions/utils/set-slack-assistant-thread-title';-import { startSlackAssistantStatusUpdates } from 'src/logic-functions/utils/start-slack-assistant-status-updates';-import { subscribeSlackThread } from 'src/logic-functions/utils/subscribe-slack-thread';type SlackAssistantRequestCreatedEvent = DatabaseEventPayload<ObjectRecordCreateEvent<SlackAssistantRequestRecord>>;-export const slackAssistantWorkerHandler = async (+// Compatibility drain for one release: requests recorded before the upgrade+// are still answered through this trigger, while requests recorded after it+// are answered inline by slack-assistant-request and lose the claim here.+export const slackAssistantWorkerDrainHandler = async (event: SlackAssistantRequestCreatedEvent,-): Promise<object> => {- const record = event.properties.after;-- if (record.status !== SLACK_ASSISTANT_REQUEST_STATUS.PENDING) {- return { skipped: true, reason: 'Request is not pending' };- }-- const { slackChannelId, slackMessageTimestamp, requestText } = record;-- if (- !isNonEmptyString(slackChannelId) ||- !isNonEmptyString(slackMessageTimestamp) ||- !isNonEmptyString(requestText)- ) {- return { skipped: true, reason: 'Request record is missing fields' };- }-- const agentDeadlineAtMs =- Date.now() + SLACK_ASSISTANT_AGENT_BUDGET_SECONDS * 1000;-- const client = new CoreApiClient();-- await updateSlackAssistantRequest(client, {- id: record.id,- status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,- });-- const isThreadStartingMessage = !isNonEmptyString(- record.slackThreadTimestamp,- );-- const parentMessageTimestamp = getSlackAssistantParentMessageTimestamp({- slackThreadTimestamp: record.slackThreadTimestamp,- slackMessageTimestamp,- });-- const failureContext = {- client,- requestId: record.id,- slackChannelId,- parentMessageTimestamp,- };-- const stopStatusUpdates = startSlackAssistantStatusUpdates({- slackChannelId,- threadTimestamp: parentMessageTimestamp,- });-- try {- const [- {- conversationMessages,- requesterName,- requesterIdentity,- requestMessage,- threadMessages,- slackClient,- assistantBotUserId,- isDirectMessage,- },- workspaceBaseUrls,- ] = await Promise.all([- fetchSlackAssistantContext({- slackChannelId,- parentMessageTimestamp,- slackMessageTimestamp,- slackUserId: record.slackUserId,- }),- fetchWorkspaceBaseUrls(),- ]);-- const runAsWorkspaceMemberId = await resolveSlackRunAsForRequest({- client,- slackClient,- assistantBotUserId,- identity: requesterIdentity,- requestId: record.id,- requestText,- requestMessage,- threadMessages,- isDirectMessage,- });-- if (isNonEmptyString(runAsWorkspaceMemberId)) {- await updateSlackAssistantRequest(client, {- id: record.id,- workspaceMemberId: runAsWorkspaceMemberId,- }).catch(() => undefined);- }-- const resolvedMentions = await resolveSlackAssistantMentions({- requestText,- conversationMessages,- client,- slackClient,- assistantBotUserId,- });-- const agentBudgetRemainingSeconds = Math.max(- Math.ceil((agentDeadlineAtMs - Date.now()) / 1000),- 0,- );-- const agentResult = await runSlackAssistantAgentWithDeadline({- agentUniversalIdentifier: SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,- runAsWorkspaceMemberId,- messages: buildSlackAssistantMessages({- requestText: resolvedMentions.requestText,- requesterName,- conversationMessages: resolvedMentions.conversationMessages,- runAsWorkspaceMemberId,- timeoutSeconds: agentBudgetRemainingSeconds,- workspaceBaseUrl: workspaceBaseUrls[0],- hasMentionedUsers: resolvedMentions.hasMentionedUsers,- }),- deadlineAtMs: agentDeadlineAtMs,- }).finally(() => stopStatusUpdates());-- if (!agentResult.success) {- return await finishSlackAssistantRequestWithFailure({- ...failureContext,- errorMessage: agentResult.error ?? 'Agent execution failed',- });- }-- const responseText = extractAgentResponseText(agentResult);-- if (responseText === undefined) {- return await finishSlackAssistantRequestWithFailure({- ...failureContext,- errorMessage: SLACK_ASSISTANT_EMPTY_RESPONSE_ERROR,- });- }-- const answerMessage: SlackPostMessageInput = {- slackChannelId,- messageText: responseText,- parentMessageTimestamp,- messageFormat: 'markdown',- unfurlLinks: false,- unfurlMedia: false,- messageBlocks: buildSlackAssistantAnswerBlocks({- responseText,- requestId: record.id,- workspaceBaseUrl: workspaceBaseUrls[0],- }),- };-- const deliveryResult = await sendSlackMessage(answerMessage, {- waitOutRateLimit: false,- });-- const deferredRetryAfterSeconds = deliveryResult.success- ? undefined- : deliveryResult.retryAfterSeconds;-- if (!deliveryResult.success && !isDefined(deferredRetryAfterSeconds)) {- return await finishSlackAssistantRequestWithFailure({- ...failureContext,- errorMessage: buildSlackAnswerDeliveryFailureMessage(deliveryResult),- });- }-- if (isDefined(deferredRetryAfterSeconds)) {- await enqueueSlackMessageDelivery({- payload: { ...answerMessage, slackAssistantRequestId: record.id },- retryAfterSeconds: deferredRetryAfterSeconds,- });- } else {- await updateSlackAssistantRequest(client, {- id: record.id,- status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,- responseText,- });- }-- if (isDirectMessage) {- if (isThreadStartingMessage) {- await setSlackAssistantThreadTitle({- slackChannelId,- threadTimestamp: parentMessageTimestamp,- title: buildSlackAssistantRequestName(requestText),- });- }- } else {- await subscribeSlackThread({- channelId: slackChannelId,- threadTimestamp: parentMessageTimestamp,- }).catch(() => undefined);- }-- return isDefined(deferredRetryAfterSeconds)- ? { deferred: true }- : { done: true };- } catch (error) {- await stopStatusUpdates();-- return await finishSlackAssistantRequestWithFailure({- ...failureContext,- errorMessage:- error instanceof Error ? error.message : 'Unexpected worker error',- });- }-};+): Promise<object> => await slackAssistantWorkerHandler(event.properties.after);export default defineLogicFunction({universalIdentifier: SLACK_ASSISTANT_WORKER_UNIVERSAL_IDENTIFIER,name: 'slack-assistant-worker',description:- 'Processes queued Slack Assistant Requests: shows a native thinking status on the conversation thread, runs the Slack Assistant agent against the workspace, and posts the answer as a threaded reply.',- timeoutSeconds: SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS,- handler: slackAssistantWorkerHandler,+ 'Answers Slack Assistant Requests recorded before the app upgrade that moved answering into slack-assistant-request. Kept for one release so queued requests are drained; requests recorded after the upgrade are already claimed and skipped here.',+ timeoutSeconds: SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS,+ handler: slackAssistantWorkerDrainHandler,databaseEventTriggerSettings: {eventName: `${SLACK_ASSISTANT_REQUEST_OBJECT_NAME}.created`,},diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-events-enqueue.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-events-enqueue.tsdeleted file mode 100644index 72db9d0cac2..00000000000--- a/packages/twenty-apps/public/slack/src/logic-functions/slack-events-enqueue.ts+++ /dev/null@@ -1,13 +0,0 @@-import { defineLogicFunction } from 'twenty-sdk/define';--import { SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';-import { enqueueSlackAssistantRequest } from 'src/logic-functions/utils/enqueue-slack-assistant-request';--export default defineLogicFunction({- universalIdentifier: SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,- name: 'slack-events-enqueue',- description:- 'Runs in the resolved workspace: enqueues a Slack Assistant Request record for the assistant worker.',- timeoutSeconds: 15,- handler: enqueueSlackAssistantRequest,-});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-events-resolver.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-events-resolver.tsindex 3f7f256c4db..01bd86ad0d0 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/slack-events-resolver.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-events-resolver.ts@@ -6,7 +6,7 @@ import { isDefined } from 'twenty-sdk/utils';import {SLACK_CHANNEL_WELCOME_UNIVERSAL_IDENTIFIER,SLACK_ENTITY_DETAILS_UNIVERSAL_IDENTIFIER,- SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER,+ SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER,SLACK_EVENTS_ROUTE_UNIVERSAL_IDENTIFIER,SLACK_HOME_OPENED_UNIVERSAL_IDENTIFIER,SLACK_INSTALL_REVOKED_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,@@ -95,7 +95,7 @@ const resolveTargetLogicFunctionUniversalIdentifier = (case 'tokens_revoked':return SLACK_INSTALL_REVOKED_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER;default:- return SLACK_EVENTS_ENQUEUE_UNIVERSAL_IDENTIFIER;+ return SLACK_ASSISTANT_REQUEST_UNIVERSAL_IDENTIFIER;}};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-assistant-request-record.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-assistant-request-record.type.tsindex 79f7bcfc812..3bcd21c9531 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-assistant-request-record.type.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-assistant-request-record.type.ts@@ -7,4 +7,5 @@ export type SlackAssistantRequestRecord = {slackMessageTimestamp?: string;slackUserId?: string;requestText?: string;+ updatedAt?: string;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-events-enqueue-result.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-events-enqueue-result.type.tsindex cceb65ec378..c7f849a19dc 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-events-enqueue-result.type.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-events-enqueue-result.type.ts@@ -1,4 +1,7 @@+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';+export type SlackEventsEnqueueResult = {ok: boolean;skipped?: string;+ request?: SlackAssistantRequestRecord;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request-record.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request-record.test.tsnew file mode 100644index 00000000000..9e1bc8ab17a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request-record.test.ts@@ -0,0 +1,143 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';+import { enqueueSlackAssistantRequestRecord } from 'src/logic-functions/utils/enqueue-slack-assistant-request-record';++const {+ coreApiClientMock,+ findSlackAssistantRequestBySlackMessageMock,+ createSlackAssistantRequestMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ findSlackAssistantRequestBySlackMessageMock: vi.fn(),+ createSlackAssistantRequestMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock(+ 'src/logic-functions/data/find-slack-assistant-request-by-slack-message',+ () => ({+ findSlackAssistantRequestBySlackMessage:+ findSlackAssistantRequestBySlackMessageMock,+ }),+);++vi.mock('src/logic-functions/data/create-slack-assistant-request', () => ({+ createSlackAssistantRequest: createSlackAssistantRequestMock,+}));++const REQUEST_DRAFT = {+ slackEventId: 'Ev123',+ slackChannelId: 'D123',+ slackChannelType: 'im',+ slackThreadTimestamp: '',+ slackMessageTimestamp: '1700000000.000100',+ slackUserId: 'U123',+ requestText: 'how many open deals does Acme have?',+};++describe('enqueueSlackAssistantRequestRecord', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ });++ it('should record a new request as pending and hand it back', async () => {+ findSlackAssistantRequestBySlackMessageMock.mockResolvedValue(undefined);+ createSlackAssistantRequestMock.mockResolvedValue('request-1');++ const result = await enqueueSlackAssistantRequestRecord(REQUEST_DRAFT);++ expect(result).toEqual({+ ok: true,+ request: {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ slackChannelId: 'D123',+ slackChannelType: 'im',+ slackThreadTimestamp: '',+ slackMessageTimestamp: '1700000000.000100',+ slackUserId: 'U123',+ requestText: 'how many open deals does Acme have?',+ },+ });+ });++ it('should hand back an unanswered request so a retry can resume it', async () => {+ const pendingRequest = {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ ...REQUEST_DRAFT,+ };++ findSlackAssistantRequestBySlackMessageMock.mockResolvedValue(+ pendingRequest,+ );++ const result = await enqueueSlackAssistantRequestRecord(REQUEST_DRAFT);++ expect(result).toEqual({ ok: true, request: pendingRequest });+ expect(createSlackAssistantRequestMock).not.toHaveBeenCalled();+ });++ it('should skip a request another execution is already answering', async () => {+ findSlackAssistantRequestBySlackMessageMock.mockResolvedValue({+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date().toISOString(),+ ...REQUEST_DRAFT,+ });++ const result = await enqueueSlackAssistantRequestRecord(REQUEST_DRAFT);++ expect(result).toEqual({+ ok: true,+ skipped: 'Slack message is already queued',+ });+ });++ it('should hand back a request whose execution died mid-answer', async () => {+ const staleRequest = {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date(+ Date.now() - (SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS + 1) * 1000,+ ).toISOString(),+ ...REQUEST_DRAFT,+ };++ findSlackAssistantRequestBySlackMessageMock.mockResolvedValue(staleRequest);++ const result = await enqueueSlackAssistantRequestRecord(REQUEST_DRAFT);++ expect(result).toEqual({ ok: true, request: staleRequest });+ });++ it('should hand back the winning record when losing the create race', async () => {+ const pendingRequest = {+ id: 'request-1',+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ ...REQUEST_DRAFT,+ };++ findSlackAssistantRequestBySlackMessageMock+ .mockResolvedValueOnce(undefined)+ .mockResolvedValueOnce(pendingRequest);+ createSlackAssistantRequestMock.mockRejectedValue(+ new Error('duplicate key value violates unique constraint'),+ );++ const result = await enqueueSlackAssistantRequestRecord(REQUEST_DRAFT);++ expect(result).toEqual({ ok: true, request: pendingRequest });+ expect(findSlackAssistantRequestBySlackMessageMock).toHaveBeenCalledTimes(+ 2,+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-slack-assistant-request-resumable.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-slack-assistant-request-resumable.test.tsnew file mode 100644index 00000000000..789d24d9ff0--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-slack-assistant-request-resumable.test.ts@@ -0,0 +1,64 @@+import { describe, expect, it } from 'vitest';++import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';+import { isSlackAssistantRequestResumable } from 'src/logic-functions/utils/is-slack-assistant-request-resumable';++const NOW_MS = Date.parse('2026-09-10T12:00:00.000Z');+const LEASE_MS = SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS * 1000;++describe('isSlackAssistantRequestResumable', () => {+ it('should resume a pending request', () => {+ expect(+ isSlackAssistantRequestResumable(+ { status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING },+ { nowMs: NOW_MS },+ ),+ ).toBe(true);+ });++ it('should leave a request whose execution can still be alive alone', () => {+ expect(+ isSlackAssistantRequestResumable(+ {+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date(NOW_MS - LEASE_MS + 1000).toISOString(),+ },+ { nowMs: NOW_MS },+ ),+ ).toBe(false);+ });++ it('should resume a request whose execution died mid-answer', () => {+ expect(+ isSlackAssistantRequestResumable(+ {+ status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING,+ updatedAt: new Date(NOW_MS - LEASE_MS - 1000).toISOString(),+ },+ { nowMs: NOW_MS },+ ),+ ).toBe(true);+ });++ it('should not resume a processing request without a last update time', () => {+ expect(+ isSlackAssistantRequestResumable(+ { status: SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING },+ { nowMs: NOW_MS },+ ),+ ).toBe(false);+ });++ it.each([+ SLACK_ASSISTANT_REQUEST_STATUS.DONE,+ SLACK_ASSISTANT_REQUEST_STATUS.FAILED,+ ])('should never resume a %s request', (status) => {+ expect(+ isSlackAssistantRequestResumable(+ { status, updatedAt: new Date(NOW_MS - LEASE_MS - 1000).toISOString() },+ { nowMs: NOW_MS },+ ),+ ).toBe(false);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request-record.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request-record.tsindex d1532bc01a8..ebf70df13a5 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request-record.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request-record.ts@@ -1,40 +1,66 @@import { CoreApiClient } from 'twenty-client-sdk/core';import { isDefined } from 'twenty-sdk/utils';+import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';import { createSlackAssistantRequest } from 'src/logic-functions/data/create-slack-assistant-request';import { findSlackAssistantRequestBySlackMessage } from 'src/logic-functions/data/find-slack-assistant-request-by-slack-message';import { type SlackAssistantRequestDraft } from 'src/logic-functions/types/slack-assistant-request-draft.type';+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';import { type SlackEventsEnqueueResult } from 'src/logic-functions/types/slack-events-enqueue-result.type';import { isDuplicateRecordError } from 'src/logic-functions/utils/is-duplicate-record-error';+import { isSlackAssistantRequestResumable } from 'src/logic-functions/utils/is-slack-assistant-request-resumable';const ALREADY_QUEUED_SKIP_REASON = 'Slack message is already queued';+const resolveExistingRequest = (+ existingRequest: SlackAssistantRequestRecord | undefined,+): SlackEventsEnqueueResult =>+ isDefined(existingRequest) &&+ isSlackAssistantRequestResumable(existingRequest)+ ? { ok: true, request: existingRequest }+ : { ok: true, skipped: ALREADY_QUEUED_SKIP_REASON };+export const enqueueSlackAssistantRequestRecord = async (request: SlackAssistantRequestDraft,): Promise<SlackEventsEnqueueResult> => {const client = new CoreApiClient();+ const slackMessageKey = {+ slackChannelId: request.slackChannelId,+ slackMessageTimestamp: request.slackMessageTimestamp,+ };- const existingRequestId = await findSlackAssistantRequestBySlackMessage(+ const existingRequest = await findSlackAssistantRequestBySlackMessage(client,- {- slackChannelId: request.slackChannelId,- slackMessageTimestamp: request.slackMessageTimestamp,- },+ slackMessageKey,);- if (isDefined(existingRequestId)) {- return { ok: true, skipped: ALREADY_QUEUED_SKIP_REASON };+ if (isDefined(existingRequest)) {+ return resolveExistingRequest(existingRequest);}try {- await createSlackAssistantRequest(client, request);+ const requestId = await createSlackAssistantRequest(client, request);++ return {+ ok: true,+ request: {+ id: requestId,+ status: SLACK_ASSISTANT_REQUEST_STATUS.PENDING,+ slackChannelId: request.slackChannelId,+ slackChannelType: request.slackChannelType,+ slackThreadTimestamp: request.slackThreadTimestamp,+ slackMessageTimestamp: request.slackMessageTimestamp,+ slackUserId: request.slackUserId,+ requestText: request.requestText,+ },+ };} catch (error) {if (isDuplicateRecordError(error)) {- return { ok: true, skipped: ALREADY_QUEUED_SKIP_REASON };+ return resolveExistingRequest(+ await findSlackAssistantRequestBySlackMessage(client, slackMessageKey),+ );}throw error;}-- return { ok: true };};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-assistant-request-lease-cutoff.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-assistant-request-lease-cutoff.tsnew file mode 100644index 00000000000..ce3d98b8d2e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-assistant-request-lease-cutoff.ts@@ -0,0 +1,7 @@+import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';++// An execution cannot outlive its timeout, so a PROCESSING record untouched+// for longer than that has no live owner and can be taken over.+export const getSlackAssistantRequestLeaseCutoff = (+ nowMs: number = Date.now(),+): Date => new Date(nowMs - SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS * 1000);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-assistant-request-resumable.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-assistant-request-resumable.tsnew file mode 100644index 00000000000..50d9436ff3d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-assistant-request-resumable.ts@@ -0,0 +1,25 @@+import { isNonEmptyString } from '@sniptt/guards';++import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';+import { type SlackAssistantRequestRecord } from 'src/logic-functions/types/slack-assistant-request-record.type';+import { getSlackAssistantRequestLeaseCutoff } from 'src/logic-functions/utils/get-slack-assistant-request-lease-cutoff';++export const isSlackAssistantRequestResumable = (+ record: Pick<SlackAssistantRequestRecord, 'status' | 'updatedAt'>,+ { nowMs = Date.now() }: { nowMs?: number } = {},+): boolean => {+ if (record.status === SLACK_ASSISTANT_REQUEST_STATUS.PENDING) {+ return true;+ }++ if (+ record.status !== SLACK_ASSISTANT_REQUEST_STATUS.PROCESSING ||+ !isNonEmptyString(record.updatedAt)+ ) {+ return false;+ }++ return (+ new Date(record.updatedAt) < getSlackAssistantRequestLeaseCutoff(nowMs)+ );+};