Skip to content

The open alternative to Salesforce, designed for AI.

feat(slack): defer rate limited message delivery to a delayed job (#25700)

Abdul Rahman38ba28ce23da
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 f0dcc3394c6..d5dec29b4da 100644
--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts
+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts
@@ -186,3 +186,6 @@ export const SLACK_USER_LINKS_SETTINGS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER =
export const SLACK_CONNECTION_STATUS_UNIVERSAL_IDENTIFIER =
'ca8af663-5229-486a-b81b-1ac9bf8e1e8f';
+
+export const SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER =
+ 'cc43a728-7b9f-43c6-a9a2-bd1196204822';
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 f056716c32e..01fc9b5378e 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
@@ -12,7 +12,7 @@ const {
fetchWorkspaceBaseUrlsMock,
resolveSlackRunAsForRequestMock,
runSlackAssistantAgentWithDeadlineMock,
- slackPostMessageHandlerMock,
+ sendSlackMessageMock,
startSlackAssistantStatusUpdatesMock,
stopStatusUpdatesMock,
finishSlackAssistantRequestWithFailureMock,
@@ -26,7 +26,7 @@ const {
fetchWorkspaceBaseUrlsMock: vi.fn(),
resolveSlackRunAsForRequestMock: vi.fn(),
runSlackAssistantAgentWithDeadlineMock: vi.fn(),
- slackPostMessageHandlerMock: vi.fn(),
+ sendSlackMessageMock: vi.fn(),
startSlackAssistantStatusUpdatesMock: vi.fn(),
stopStatusUpdatesMock: vi.fn(),
finishSlackAssistantRequestWithFailureMock: vi.fn(),
@@ -61,8 +61,8 @@ vi.mock(
}),
);
-vi.mock('src/logic-functions/handlers/slack-post-message-handler', () => ({
- slackPostMessageHandler: slackPostMessageHandlerMock,
+vi.mock('src/logic-functions/utils/send-slack-message', () => ({
+ sendSlackMessage: sendSlackMessageMock,
}));
vi.mock(
@@ -156,7 +156,7 @@ describe('slackAssistantWorkerHandler', () => {
return { success: true, error: null, result: { response: 'Two.' } };
});
- slackPostMessageHandlerMock.mockImplementation(async () => {
+ sendSlackMessageMock.mockImplementation(async () => {
callLog.push('reply:answer');
return { success: true, slackTs: '1700000000.000200' };
@@ -180,12 +180,12 @@ describe('slackAssistantWorkerHandler', () => {
'status:stop',
'reply:answer',
]);
- expect(startSlackAssistantStatusUpdatesMock).toHaveBeenCalledExactlyOnceWith(
- {
- slackChannelId: REQUEST_RECORD.slackChannelId,
- threadTimestamp: REQUEST_RECORD.slackMessageTimestamp,
- },
- );
+ 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 () => {
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-max-attempts.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-max-attempts.ts
new file mode 100644
index 00000000000..88b451630ff
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-max-attempts.ts
@@ -0,0 +1 @@
+export const SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS = 5;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-timeout-seconds.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-timeout-seconds.ts
new file mode 100644
index 00000000000..fcdb30be4e5
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-message-delivery-timeout-seconds.ts
@@ -0,0 +1 @@
+export const SLACK_MESSAGE_DELIVERY_TIMEOUT_SECONDS = 30;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-deliver-message-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-deliver-message-handler.test.ts
new file mode 100644
index 00000000000..3c2da3c7d95
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-deliver-message-handler.test.ts
@@ -0,0 +1,163 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS } from 'src/logic-functions/constants/slack-message-delivery-max-attempts';
+import { slackDeliverMessageHandler } from 'src/logic-functions/handlers/slack-deliver-message-handler';
+
+const {
+ sendSlackMessageMock,
+ enqueueDeliveryMock,
+ updateRequestMock,
+ finishWithFailureMock,
+} = vi.hoisted(() => ({
+ sendSlackMessageMock: vi.fn(),
+ enqueueDeliveryMock: vi.fn(),
+ updateRequestMock: vi.fn(),
+ finishWithFailureMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/send-slack-message', () => ({
+ sendSlackMessage: sendSlackMessageMock,
+}));
+
+vi.mock('src/logic-functions/utils/enqueue-slack-message-delivery', () => ({
+ enqueueSlackMessageDelivery: enqueueDeliveryMock,
+}));
+
+vi.mock('src/logic-functions/data/update-slack-assistant-request', () => ({
+ updateSlackAssistantRequest: updateRequestMock,
+}));
+
+vi.mock(
+ 'src/logic-functions/utils/finish-slack-assistant-request-with-failure',
+ () => ({ finishSlackAssistantRequestWithFailure: finishWithFailureMock }),
+);
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: class {},
+}));
+
+const CHANNEL_ID = 'C0123456789';
+const REQUEST_ID = '7b1a0f2e-1c2d-4a3b-9e8f-0a1b2c3d4e5f';
+
+const ANSWER_PAYLOAD = {
+ slackChannelId: CHANNEL_ID,
+ messageText: 'here is your answer',
+ parentMessageTimestamp: '1700000000.000100',
+ slackAssistantRequestId: REQUEST_ID,
+};
+
+describe('slackDeliverMessageHandler', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should mark the assistant request done once the message is delivered', async () => {
+ sendSlackMessageMock.mockResolvedValue({
+ success: true,
+ message: 'Message posted to Slack.',
+ });
+
+ const result = await slackDeliverMessageHandler(ANSWER_PAYLOAD);
+
+ expect(result).toEqual({
+ delivered: true,
+ attempt: 1,
+ statusRecorded: true,
+ });
+ expect(sendSlackMessageMock).toHaveBeenCalledWith(expect.anything(), {
+ waitOutRateLimit: false,
+ });
+ expect(updateRequestMock).toHaveBeenCalledWith(expect.anything(), {
+ id: REQUEST_ID,
+ status: 'DONE',
+ responseText: 'here is your answer',
+ });
+ expect(enqueueDeliveryMock).not.toHaveBeenCalled();
+ });
+
+ it('should reschedule with the delay Slack asked for when still rate limited', async () => {
+ sendSlackMessageMock.mockResolvedValue({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'A rate limit was exceeded',
+ retryAfterSeconds: 12,
+ });
+
+ const result = await slackDeliverMessageHandler(ANSWER_PAYLOAD);
+
+ expect(result).toEqual({
+ delivered: false,
+ attempt: 1,
+ rescheduled: true,
+ });
+ expect(enqueueDeliveryMock).toHaveBeenCalledWith({
+ payload: ANSWER_PAYLOAD,
+ retryAfterSeconds: 12,
+ });
+ expect(updateRequestMock).not.toHaveBeenCalled();
+ expect(finishWithFailureMock).not.toHaveBeenCalled();
+ });
+
+ it('should stop rescheduling and fail the request once the attempt cap is reached', async () => {
+ sendSlackMessageMock.mockResolvedValue({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'A rate limit was exceeded',
+ retryAfterSeconds: 12,
+ });
+
+ const result = await slackDeliverMessageHandler({
+ ...ANSWER_PAYLOAD,
+ attempt: SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS,
+ });
+
+ expect(result).toEqual({
+ delivered: false,
+ attempt: SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS,
+ rescheduled: false,
+ error: 'Could not deliver Slack answer: A rate limit was exceeded',
+ });
+ expect(enqueueDeliveryMock).not.toHaveBeenCalled();
+ expect(finishWithFailureMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ requestId: REQUEST_ID,
+ slackChannelId: CHANNEL_ID,
+ parentMessageTimestamp: '1700000000.000100',
+ }),
+ );
+ });
+
+ it('should not touch any assistant request when the payload carries none', async () => {
+ sendSlackMessageMock.mockResolvedValue({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'channel_not_found',
+ });
+
+ const result = await slackDeliverMessageHandler({
+ slackChannelId: CHANNEL_ID,
+ messageText: 'consent request',
+ });
+
+ expect(result.delivered).toBe(false);
+ expect(updateRequestMock).not.toHaveBeenCalled();
+ expect(finishWithFailureMock).not.toHaveBeenCalled();
+ });
+
+ it('should keep the job successful when the status write fails after posting', async () => {
+ sendSlackMessageMock.mockResolvedValue({
+ success: true,
+ message: 'Message posted to Slack.',
+ });
+ updateRequestMock.mockRejectedValue(new Error('core api unreachable'));
+
+ const result = await slackDeliverMessageHandler(ANSWER_PAYLOAD);
+
+ expect(result).toEqual({
+ delivered: true,
+ attempt: 1,
+ statusRecorded: false,
+ });
+ expect(enqueueDeliveryMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-deliver-message-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-deliver-message-handler.ts
new file mode 100644
index 00000000000..93d8b69b99e
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-deliver-message-handler.ts
@@ -0,0 +1,67 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { CoreApiClient } from 'twenty-client-sdk/core';
+import { isDefined } from 'twenty-sdk/utils';
+
+import { SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS } from 'src/logic-functions/constants/slack-message-delivery-max-attempts';
+import { type SlackDeliverMessagePayload } from 'src/logic-functions/types/slack-deliver-message-payload.type';
+import { type SlackDeliverMessageResult } from 'src/logic-functions/types/slack-deliver-message-result.type';
+import { buildSlackAnswerDeliveryFailureMessage } from 'src/logic-functions/utils/build-slack-answer-delivery-failure-message';
+import { enqueueSlackMessageDelivery } from 'src/logic-functions/utils/enqueue-slack-message-delivery';
+import { finishSlackAssistantRequestWithFailure } from 'src/logic-functions/utils/finish-slack-assistant-request-with-failure';
+import { markSlackAssistantRequestDone } from 'src/logic-functions/utils/mark-slack-assistant-request-done';
+import { sendSlackMessage } from 'src/logic-functions/utils/send-slack-message';
+
+export const slackDeliverMessageHandler = async (
+ payload: SlackDeliverMessagePayload,
+): Promise<SlackDeliverMessageResult> => {
+ const { attempt = 1, slackAssistantRequestId, ...message } = payload;
+
+ const result = await sendSlackMessage(message, {
+ waitOutRateLimit: false,
+ });
+
+ if (result.success) {
+ const statusRecorded = isNonEmptyString(slackAssistantRequestId)
+ ? await markSlackAssistantRequestDone({
+ requestId: slackAssistantRequestId,
+ responseText: message.messageText,
+ })
+ : true;
+
+ return { delivered: true, attempt, statusRecorded };
+ }
+
+ if (
+ isDefined(result.retryAfterSeconds) &&
+ attempt < SLACK_MESSAGE_DELIVERY_MAX_ATTEMPTS
+ ) {
+ await enqueueSlackMessageDelivery({
+ payload,
+ retryAfterSeconds: result.retryAfterSeconds,
+ });
+
+ return { delivered: false, attempt, rescheduled: true };
+ }
+
+ const failureMessage = buildSlackAnswerDeliveryFailureMessage(result);
+
+ if (
+ isNonEmptyString(slackAssistantRequestId) &&
+ isNonEmptyString(message.parentMessageTimestamp)
+ ) {
+ await finishSlackAssistantRequestWithFailure({
+ client: new CoreApiClient(),
+ requestId: slackAssistantRequestId,
+ slackChannelId: message.slackChannelId,
+ parentMessageTimestamp: message.parentMessageTimestamp,
+ errorMessage: failureMessage,
+ });
+ }
+
+ return {
+ delivered: false,
+ attempt,
+ rescheduled: false,
+ error: failureMessage,
+ };
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-post-message-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-post-message-handler.ts
index e8b5e9f4be2..d29860aaf2a 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-post-message-handler.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-post-message-handler.ts
@@ -1,20 +1,7 @@
import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';
import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';
-import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';
-import { postSlackMessage } from 'src/logic-functions/utils/post-slack-message';
+import { sendSlackMessage } from 'src/logic-functions/utils/send-slack-message';
export const slackPostMessageHandler = async (
parameters: SlackPostMessageInput,
-): Promise<SlackToolResult> => {
- const slackClientResult = await getSlackClient();
-
- if (!slackClientResult.success) {
- return {
- success: false,
- message: 'Slack is not connected',
- error: slackClientResult.error,
- };
- }
-
- return await postSlackMessage(slackClientResult.client, parameters);
-};
+): Promise<SlackToolResult> => await sendSlackMessage(parameters);
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 8705290aaba..2008b113c96 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
@@ -5,6 +5,7 @@ import {
defineLogicFunction,
type ObjectRecordCreateEvent,
} from 'twenty-sdk/define';
+import { isDefined } from 'twenty-sdk/utils';
import {
SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,
@@ -16,11 +17,13 @@ import { SLACK_ASSISTANT_REQUEST_OBJECT_NAME } from 'src/logic-functions/constan
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 { slackPostMessageHandler } from 'src/logic-functions/handlers/slack-post-message-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';
@@ -28,6 +31,7 @@ import { finishSlackAssistantRequestWithFailure } from 'src/logic-functions/util
import { getSlackAssistantParentMessageTimestamp } from 'src/logic-functions/utils/get-slack-assistant-parent-message-timestamp';
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';
@@ -163,7 +167,7 @@ export const slackAssistantWorkerHandler = async (
});
}
- const deliveryResult = await slackPostMessageHandler({
+ const answerMessage: SlackPostMessageInput = {
slackChannelId,
messageText: responseText,
parentMessageTimestamp,
@@ -175,20 +179,35 @@ export const slackAssistantWorkerHandler = async (
requestId: record.id,
workspaceBaseUrl: workspaceBaseUrls[0],
}),
+ };
+
+ const deliveryResult = await sendSlackMessage(answerMessage, {
+ waitOutRateLimit: false,
});
- if (!deliveryResult.success) {
+ const deferredRetryAfterSeconds = deliveryResult.success
+ ? undefined
+ : deliveryResult.retryAfterSeconds;
+
+ if (!deliveryResult.success && !isDefined(deferredRetryAfterSeconds)) {
return await finishSlackAssistantRequestWithFailure({
...failureContext,
- errorMessage: `Could not deliver Slack answer: ${deliveryResult.error ?? deliveryResult.message}`,
+ errorMessage: buildSlackAnswerDeliveryFailureMessage(deliveryResult),
});
}
- await updateSlackAssistantRequest(client, {
- id: record.id,
- status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,
- responseText,
- });
+ 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) {
@@ -205,7 +224,9 @@ export const slackAssistantWorkerHandler = async (
}).catch(() => undefined);
}
- return { done: true };
+ return isDefined(deferredRetryAfterSeconds)
+ ? { deferred: true }
+ : { done: true };
} catch (error) {
await stopStatusUpdates();
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-deliver-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-deliver-message.ts
new file mode 100644
index 00000000000..cf549ebaaf1
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-deliver-message.ts
@@ -0,0 +1,14 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { SLACK_MESSAGE_DELIVERY_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-message-delivery-timeout-seconds';
+import { slackDeliverMessageHandler } from 'src/logic-functions/handlers/slack-deliver-message-handler';
+
+export default defineLogicFunction({
+ universalIdentifier: SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER,
+ name: 'slack-deliver-message',
+ description:
+ 'Posts a single Slack message that was rate limited on its first attempt. Enqueued with the delay Slack asked for, so the calling function never waits on a 429.',
+ timeoutSeconds: SLACK_MESSAGE_DELIVERY_TIMEOUT_SECONDS,
+ handler: slackDeliverMessageHandler,
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-payload.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-payload.type.ts
new file mode 100644
index 00000000000..fa2fe155979
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-payload.type.ts
@@ -0,0 +1,6 @@
+import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';
+
+export type SlackDeliverMessagePayload = SlackPostMessageInput & {
+ attempt?: number;
+ slackAssistantRequestId?: string;
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-result.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-result.type.ts
new file mode 100644
index 00000000000..f1b8dce7661
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-deliver-message-result.type.ts
@@ -0,0 +1,4 @@
+export type SlackDeliverMessageResult =
+ | { delivered: true; attempt: number; statusRecorded: boolean }
+ | { delivered: false; attempt: number; rescheduled: true }
+ | { delivered: false; attempt: number; rescheduled: false; error: string };
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-post-message-options.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-post-message-options.type.ts
new file mode 100644
index 00000000000..8f1f0f7d155
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-post-message-options.type.ts
@@ -0,0 +1,3 @@
+export type SlackPostMessageOptions = {
+ waitOutRateLimit?: boolean;
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-tool-result.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-tool-result.type.ts
index 1da8a4b576e..3658855f99b 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-tool-result.type.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-tool-result.type.ts
@@ -4,4 +4,5 @@ export type SlackToolResult = {
error?: string;
slackTs?: string;
channel?: string;
+ retryAfterSeconds?: number;
};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-message-delivery.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-message-delivery.test.ts
new file mode 100644
index 00000000000..1276d6a0675
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-message-delivery.test.ts
@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { enqueueSlackMessageDelivery } from 'src/logic-functions/utils/enqueue-slack-message-delivery';
+
+const { enqueueJobsMock } = vi.hoisted(() => ({ enqueueJobsMock: vi.fn() }));
+
+vi.mock('twenty-sdk/logic-function', () => ({ enqueueJobs: enqueueJobsMock }));
+
+const MESSAGE = {
+ slackChannelId: 'C0123456789',
+ messageText: 'here is your answer',
+};
+
+describe('enqueueSlackMessageDelivery', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should schedule the first retry at the delay Slack asked for', async () => {
+ await enqueueSlackMessageDelivery({
+ payload: MESSAGE,
+ retryAfterSeconds: 3,
+ });
+
+ expect(enqueueJobsMock).toHaveBeenCalledWith({
+ logicFunctionUniversalIdentifier:
+ SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER,
+ payloads: [{ ...MESSAGE, attempt: 1 }],
+ delayMs: 3000,
+ });
+ });
+
+ it('should count attempts across the chain so it cannot reschedule forever', async () => {
+ await enqueueSlackMessageDelivery({
+ payload: { ...MESSAGE, attempt: 2 },
+ retryAfterSeconds: 1,
+ });
+
+ expect(enqueueJobsMock).toHaveBeenCalledWith(
+ expect.objectContaining({ payloads: [{ ...MESSAGE, attempt: 3 }] }),
+ );
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-message.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-message.test.ts
new file mode 100644
index 00000000000..83db3dad1f3
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-message.test.ts
@@ -0,0 +1,66 @@
+import { ErrorCode } from '@slack/web-api';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { sendSlackMessage } from 'src/logic-functions/utils/send-slack-message';
+
+const { getSlackClientMock, postMessageMock } = vi.hoisted(() => ({
+ getSlackClientMock: vi.fn(),
+ postMessageMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/get-slack-client', () => ({
+ getSlackClient: getSlackClientMock,
+}));
+
+const CHANNEL_ID = 'C0123456789';
+
+const RATE_LIMITED_ERROR = Object.assign(
+ new Error('A rate limit was exceeded'),
+ { code: ErrorCode.RateLimitedError, retryAfter: 9 },
+);
+
+describe('sendSlackMessage', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ getSlackClientMock.mockResolvedValue({
+ success: true,
+ client: { chat: { postMessage: postMessageMock } },
+ });
+ });
+
+ it('should surface the Retry-After without waiting when asked not to wait out a rate limit', async () => {
+ postMessageMock.mockRejectedValue(RATE_LIMITED_ERROR);
+
+ const result = await sendSlackMessage(
+ { slackChannelId: CHANNEL_ID, messageText: 'hello' },
+ { waitOutRateLimit: false },
+ );
+
+ expect(postMessageMock).toHaveBeenCalledTimes(1);
+ expect(result).toEqual({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'A rate limit was exceeded',
+ retryAfterSeconds: 9,
+ });
+ });
+
+ it('should return the connection error without posting when Slack is not connected', async () => {
+ getSlackClientMock.mockResolvedValue({
+ success: false,
+ error: 'Slack is not connected.',
+ });
+
+ const result = await sendSlackMessage({
+ slackChannelId: CHANNEL_ID,
+ messageText: 'hello',
+ });
+
+ expect(result).toEqual({
+ success: false,
+ message: 'Slack is not connected',
+ error: 'Slack is not connected.',
+ });
+ expect(postMessageMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-user-link-consent-dm.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-user-link-consent-dm.test.ts
new file mode 100644
index 00000000000..8b9e2e9771a
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/send-slack-user-link-consent-dm.test.ts
@@ -0,0 +1,100 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { sendSlackUserLinkConsentDm } from 'src/logic-functions/utils/send-slack-user-link-consent-dm';
+
+const { postSlackMessageMock, enqueueDeliveryMock } = vi.hoisted(() => ({
+ postSlackMessageMock: vi.fn(),
+ enqueueDeliveryMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/post-slack-message', () => ({
+ postSlackMessage: postSlackMessageMock,
+}));
+
+vi.mock('src/logic-functions/utils/enqueue-slack-message-delivery', () => ({
+ enqueueSlackMessageDelivery: enqueueDeliveryMock,
+}));
+
+const DM_CHANNEL_ID = 'D0123456789';
+
+const CONSENT_REQUEST = {
+ slackTeamId: 'T1',
+ slackUserId: 'U1',
+ workspaceMemberId: 'member-1',
+ slackUserLinkId: 'link-1',
+ memberName: 'Ada Member',
+};
+
+const buildSlackClient = (openResult: unknown) =>
+ ({
+ conversations: { open: vi.fn().mockResolvedValue(openResult) },
+ }) as never;
+
+describe('sendSlackUserLinkConsentDm', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should post the consent request in the opened direct message', async () => {
+ postSlackMessageMock.mockResolvedValue({ success: true, message: 'ok' });
+
+ const result = await sendSlackUserLinkConsentDm(
+ buildSlackClient({ channel: { id: DM_CHANNEL_ID } }),
+ CONSENT_REQUEST,
+ );
+
+ expect(result).toEqual({ success: true });
+ expect(postSlackMessageMock).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ slackChannelId: DM_CHANNEL_ID }),
+ { waitOutRateLimit: false },
+ );
+ expect(enqueueDeliveryMock).not.toHaveBeenCalled();
+ });
+
+ it('should defer the consent request to a delayed job when Slack rate limits it', async () => {
+ postSlackMessageMock.mockResolvedValue({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'A rate limit was exceeded',
+ retryAfterSeconds: 7,
+ });
+
+ const result = await sendSlackUserLinkConsentDm(
+ buildSlackClient({ channel: { id: DM_CHANNEL_ID } }),
+ CONSENT_REQUEST,
+ );
+
+ expect(result).toEqual({ success: true });
+ expect(enqueueDeliveryMock).toHaveBeenCalledWith({
+ payload: postSlackMessageMock.mock.calls[0][1],
+ retryAfterSeconds: 7,
+ });
+ });
+
+ it('should report any other delivery failure without deferring', async () => {
+ postSlackMessageMock.mockResolvedValue({
+ success: false,
+ message: 'Failed to post Slack message',
+ error: 'channel_not_found',
+ });
+
+ const result = await sendSlackUserLinkConsentDm(
+ buildSlackClient({ channel: { id: DM_CHANNEL_ID } }),
+ CONSENT_REQUEST,
+ );
+
+ expect(result).toEqual({ success: false, error: 'channel_not_found' });
+ expect(enqueueDeliveryMock).not.toHaveBeenCalled();
+ });
+
+ it('should fail when Slack does not open a direct message', async () => {
+ const result = await sendSlackUserLinkConsentDm(
+ buildSlackClient({ channel: undefined }),
+ CONSENT_REQUEST,
+ );
+
+ expect(result.success).toBe(false);
+ expect(postSlackMessageMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/slack-tool-failure.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/slack-tool-failure.test.ts
index 01f1f5edac4..b15b622b75d 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/slack-tool-failure.test.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/slack-tool-failure.test.ts
@@ -1,3 +1,4 @@
+import { ErrorCode } from '@slack/web-api';
import { describe, expect, it } from 'vitest';
import { slackToolFailure } from 'src/logic-functions/utils/slack-tool-failure';
@@ -25,4 +26,25 @@ describe('slackToolFailure', () => {
error: 'Slack request failed',
});
});
+
+ it('should surface the Retry-After so callers can defer delivery', () => {
+ const result = slackToolFailure(
+ 'Failed to post Slack message',
+ Object.assign(new Error('A rate limit was exceeded'), {
+ code: ErrorCode.RateLimitedError,
+ retryAfter: 30,
+ }),
+ );
+
+ expect(result.retryAfterSeconds).toBe(30);
+ });
+
+ it('should leave the Retry-After unset for every other Slack error', () => {
+ const result = slackToolFailure(
+ 'Failed to post Slack message',
+ new Error('channel_not_found'),
+ );
+
+ expect(result.retryAfterSeconds).toBeUndefined();
+ });
});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-answer-delivery-failure-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-answer-delivery-failure-message.ts
new file mode 100644
index 00000000000..3e09d9d3e17
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-answer-delivery-failure-message.ts
@@ -0,0 +1,6 @@
+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';
+
+export const buildSlackAnswerDeliveryFailureMessage = (
+ result: SlackToolResult,
+): string =>
+ `Could not deliver Slack answer: ${result.error ?? result.message}`;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-message-delivery.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-message-delivery.ts
new file mode 100644
index 00000000000..344454f34cf
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-message-delivery.ts
@@ -0,0 +1,19 @@
+import { enqueueJobs } from 'twenty-sdk/logic-function';
+
+import { SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { type SlackDeliverMessagePayload } from 'src/logic-functions/types/slack-deliver-message-payload.type';
+
+export const enqueueSlackMessageDelivery = async ({
+ payload,
+ retryAfterSeconds,
+}: {
+ payload: SlackDeliverMessagePayload;
+ retryAfterSeconds: number;
+}): Promise<void> => {
+ await enqueueJobs({
+ logicFunctionUniversalIdentifier:
+ SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER,
+ payloads: [{ ...payload, attempt: (payload.attempt ?? 0) + 1 }],
+ delayMs: retryAfterSeconds * 1000,
+ });
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/mark-slack-assistant-request-done.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/mark-slack-assistant-request-done.ts
new file mode 100644
index 00000000000..3a78a023166
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/mark-slack-assistant-request-done.ts
@@ -0,0 +1,30 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';
+import { updateSlackAssistantRequest } from 'src/logic-functions/data/update-slack-assistant-request';
+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';
+
+// a failed status write must not fail the job: a retry would post the answer twice
+export const markSlackAssistantRequestDone = async ({
+ requestId,
+ responseText,
+}: {
+ requestId: string;
+ responseText: string;
+}): Promise<boolean> => {
+ try {
+ await updateSlackAssistantRequest(new CoreApiClient(), {
+ id: requestId,
+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,
+ responseText,
+ });
+
+ return true;
+ } catch (error) {
+ console.warn(
+ `[slack] delivered request ${requestId} but could not mark it done: ${toErrorMessage(error)}`,
+ );
+
+ return false;
+ }
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/post-slack-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/post-slack-message.ts
index 3c9ea18b809..3913da695eb 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/post-slack-message.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/post-slack-message.ts
@@ -2,6 +2,7 @@ import { type EntityMetadata, type WebClient } from '@slack/web-api';
import { isDefined } from 'twenty-sdk/utils';
import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';
+import { type SlackPostMessageOptions } from 'src/logic-functions/types/slack-post-message-options.type';
import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';
import { buildSlackRecordEntitiesForMessage } from 'src/logic-functions/utils/build-slack-record-entities-for-message';
import { getSlackApiErrorCode } from 'src/logic-functions/utils/get-slack-api-error-code';
@@ -13,6 +14,7 @@ import { sendSlackMessageWithBodyFallbacks } from 'src/logic-functions/utils/sen
export const postSlackMessage = async (
client: WebClient,
parameters: SlackPostMessageInput,
+ { waitOutRateLimit = true }: SlackPostMessageOptions = {},
): Promise<SlackToolResult> => {
const parentTimestamp = normalizeSlackParentMessageTimestamp(
parameters.parentMessageTimestamp,
@@ -33,23 +35,25 @@ export const postSlackMessage = async (
},
failureMessage: 'Failed to post Slack message',
sendMessage: async (bodyFields) => {
- try {
- const data = await retrySlackCallWhenRateLimited({
- call: async () =>
- client.chat.postMessage({
- channel: parameters.slackChannelId,
- thread_ts: parentTimestamp,
- ...(isDefined(parameters.unfurlLinks)
- ? { unfurl_links: parameters.unfurlLinks }
- : {}),
- ...(isDefined(parameters.unfurlMedia)
- ? { unfurl_media: parameters.unfurlMedia }
- : {}),
- ...(entities.length > 0 ? { metadata: { entities } } : {}),
- ...bodyFields,
- }),
+ const call = async () =>
+ client.chat.postMessage({
+ channel: parameters.slackChannelId,
+ thread_ts: parentTimestamp,
+ ...(isDefined(parameters.unfurlLinks)
+ ? { unfurl_links: parameters.unfurlLinks }
+ : {}),
+ ...(isDefined(parameters.unfurlMedia)
+ ? { unfurl_media: parameters.unfurlMedia }
+ : {}),
+ ...(entities.length > 0 ? { metadata: { entities } } : {}),
+ ...bodyFields,
});
+ try {
+ const data = await (waitOutRateLimit
+ ? retrySlackCallWhenRateLimited({ call })
+ : call());
+
return {
success: true,
message: data.ts
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-message.ts
new file mode 100644
index 00000000000..4efbc8229d2
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-message.ts
@@ -0,0 +1,22 @@
+import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';
+import { type SlackPostMessageOptions } from 'src/logic-functions/types/slack-post-message-options.type';
+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';
+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';
+import { postSlackMessage } from 'src/logic-functions/utils/post-slack-message';
+
+export const sendSlackMessage = async (
+ parameters: SlackPostMessageInput,
+ options: SlackPostMessageOptions = {},
+): Promise<SlackToolResult> => {
+ const slackClientResult = await getSlackClient();
+
+ if (!slackClientResult.success) {
+ return {
+ success: false,
+ message: 'Slack is not connected',
+ error: slackClientResult.error,
+ };
+ }
+
+ return await postSlackMessage(slackClientResult.client, parameters, options);
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts
index c6944a80d59..36f3e1ad2e0 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts
@@ -1,8 +1,11 @@
import { type WebClient } from '@slack/web-api';
import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-sdk/utils';
+import { type SlackPostMessageInput } from 'src/logic-functions/types/slack-post-message-input.type';
import { buildSlackUserLinkConsentBlocks } from 'src/logic-functions/utils/build-slack-user-link-consent-blocks';
-import { retrySlackCallWhenRateLimited } from 'src/logic-functions/utils/retry-slack-call-when-rate-limited';
+import { enqueueSlackMessageDelivery } from 'src/logic-functions/utils/enqueue-slack-message-delivery';
+import { postSlackMessage } from 'src/logic-functions/utils/post-slack-message';
import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';
export const sendSlackUserLinkConsentDm = async (
@@ -35,22 +38,40 @@ export const sendSlackUserLinkConsentDm = async (
};
}
- await retrySlackCallWhenRateLimited({
- call: async () =>
- slackClient.chat.postMessage({
- channel: channelId,
- text: 'A Twenty admin asked to link your Slack account. Approve or decline it here.',
- blocks: buildSlackUserLinkConsentBlocks({
- memberName,
- slackTeamId,
- slackUserId,
- workspaceMemberId,
- slackUserLinkId,
- }),
- }),
+ const consentMessage: SlackPostMessageInput = {
+ slackChannelId: channelId,
+ messageText:
+ 'A Twenty admin asked to link your Slack account. Approve or decline it here.',
+ messageBlocks: buildSlackUserLinkConsentBlocks({
+ memberName,
+ slackTeamId,
+ slackUserId,
+ workspaceMemberId,
+ slackUserLinkId,
+ }),
+ };
+
+ const deliveryResult = await postSlackMessage(slackClient, consentMessage, {
+ waitOutRateLimit: false,
});
- return { success: true };
+ if (deliveryResult.success) {
+ return { success: true };
+ }
+
+ if (isDefined(deliveryResult.retryAfterSeconds)) {
+ await enqueueSlackMessageDelivery({
+ payload: consentMessage,
+ retryAfterSeconds: deliveryResult.retryAfterSeconds,
+ });
+
+ return { success: true };
+ }
+
+ return {
+ success: false,
+ error: deliveryResult.error ?? deliveryResult.message,
+ };
} catch (error) {
return {
success: false,
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/slack-tool-failure.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/slack-tool-failure.ts
index 52f0a6e124a..1045c2d6197 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/slack-tool-failure.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/slack-tool-failure.ts
@@ -1,4 +1,5 @@
import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';
+import { isSlackRateLimitedError } from 'src/logic-functions/utils/is-slack-rate-limited-error';
export const slackToolFailure = (
message: string,
@@ -7,4 +8,7 @@ export const slackToolFailure = (
success: false,
message,
error: error instanceof Error ? error.message : 'Slack request failed',
+ ...(isSlackRateLimitedError(error)
+ ? { retryAfterSeconds: error.retryAfter }
+ : {}),
});