Skip to content

The open alternative to Salesforce, designed for AI.

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.json
index 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.ts
index 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/constant
import { 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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)
+ );
+};