Skip to content

The open alternative to Salesforce, designed for AI.

fix(slack): post the assistant failure reply on its own deadline (#25285)

Abdul Rahmandde50cb5c877
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
new file mode 100644
index 00000000000..82c40e2cc51
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-agent-budget-seconds.ts
@@ -0,0 +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';
+
+export const SLACK_ASSISTANT_AGENT_BUDGET_SECONDS =
+ SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS -
+ SLACK_ASSISTANT_FAILURE_REPLY_RESERVE_SECONDS;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-deadline-error.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-deadline-error.ts
new file mode 100644
index 00000000000..0093054e781
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-deadline-error.ts
@@ -0,0 +1,2 @@
+export const SLACK_ASSISTANT_DEADLINE_ERROR =
+ 'Agent did not finish before the Slack answer deadline';
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-failure-reply-reserve-seconds.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-failure-reply-reserve-seconds.ts
new file mode 100644
index 00000000000..dff98388c37
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-assistant-failure-reply-reserve-seconds.ts
@@ -0,0 +1 @@
+export const SLACK_ASSISTANT_FAILURE_REPLY_RESERVE_SECONDS = 30;
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 238e8d2e096..35a7f5bb364 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
@@ -10,6 +10,7 @@ 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_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 { SLACK_MARKDOWN_BLOCK_MAX_LENGTH } from 'src/logic-functions/constants/slack-markdown-block-max-length';
@@ -54,6 +55,9 @@ export const slackAssistantWorkerHandler = async (
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, {
@@ -119,6 +123,11 @@ export const slackAssistantWorkerHandler = async (
}).catch(() => undefined);
}
+ const agentBudgetRemainingSeconds = Math.max(
+ Math.ceil((agentDeadlineAtMs - Date.now()) / 1000),
+ 0,
+ );
+
const agentResult = await runSlackAssistantAgentWithStatus({
agentUniversalIdentifier: SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,
runAsWorkspaceMemberId,
@@ -127,11 +136,12 @@ export const slackAssistantWorkerHandler = async (
requesterName,
conversationMessages,
runAsWorkspaceMemberId,
- timeoutSeconds: SLACK_ASSISTANT_WORKER_TIMEOUT_SECONDS,
+ timeoutSeconds: agentBudgetRemainingSeconds,
workspaceBaseUrl: workspaceBaseUrls[0],
}),
slackChannelId,
threadTimestamp: parentMessageTimestamp,
+ deadlineAtMs: agentDeadlineAtMs,
});
if (!agentResult.success) {
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/race-slack-assistant-agent-deadline.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/race-slack-assistant-agent-deadline.test.ts
new file mode 100644
index 00000000000..484201e2cb0
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/race-slack-assistant-agent-deadline.test.ts
@@ -0,0 +1,99 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SLACK_ASSISTANT_DEADLINE_ERROR } from 'src/logic-functions/constants/slack-assistant-deadline-error';
+import { raceSlackAssistantAgentDeadline } from 'src/logic-functions/utils/race-slack-assistant-agent-deadline';
+
+const AGENT_RESULT = {
+ result: { text: 'Acme has 3 open deals' },
+ error: null,
+ success: true,
+};
+
+describe('raceSlackAssistantAgentDeadline', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('should return the agent result when the agent finishes first', async () => {
+ const race = raceSlackAssistantAgentDeadline({
+ agentRun: Promise.resolve(AGENT_RESULT),
+ deadlineAtMs: Date.now() + 10_000,
+ });
+
+ await expect(race).resolves.toEqual(AGENT_RESULT);
+ });
+
+ it('should return a failed result when the deadline passes first', async () => {
+ const race = raceSlackAssistantAgentDeadline({
+ agentRun: new Promise(() => undefined),
+ deadlineAtMs: Date.now() + 10_000,
+ });
+
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ await expect(race).resolves.toEqual({
+ result: null,
+ error: SLACK_ASSISTANT_DEADLINE_ERROR,
+ success: false,
+ });
+ });
+
+ it('should not resolve before the deadline while the agent is still running', async () => {
+ let isSettled = false;
+
+ const race = raceSlackAssistantAgentDeadline({
+ agentRun: new Promise(() => undefined),
+ deadlineAtMs: Date.now() + 10_000,
+ }).then((result) => {
+ isSettled = true;
+
+ return result;
+ });
+
+ await vi.advanceTimersByTimeAsync(9_999);
+
+ expect(isSettled).toBe(false);
+
+ await vi.advanceTimersByTimeAsync(1);
+ await race;
+
+ expect(isSettled).toBe(true);
+ });
+
+ it('should fail immediately when the deadline has already passed', async () => {
+ const race = raceSlackAssistantAgentDeadline({
+ agentRun: new Promise(() => undefined),
+ deadlineAtMs: Date.now() - 5_000,
+ });
+
+ await vi.advanceTimersByTimeAsync(0);
+
+ await expect(race).resolves.toEqual({
+ result: null,
+ error: SLACK_ASSISTANT_DEADLINE_ERROR,
+ success: false,
+ });
+ });
+
+ it('should leave no pending deadline timer once the agent has answered', async () => {
+ await raceSlackAssistantAgentDeadline({
+ agentRun: Promise.resolve(AGENT_RESULT),
+ deadlineAtMs: Date.now() + 10_000,
+ });
+
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('should surface an agent rejection rather than waiting for the deadline', async () => {
+ const race = raceSlackAssistantAgentDeadline({
+ agentRun: Promise.reject(new Error('Agent blew up')),
+ deadlineAtMs: Date.now() + 10_000,
+ });
+
+ await expect(race).rejects.toThrow('Agent blew up');
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-status.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-status.test.ts
new file mode 100644
index 00000000000..f4a508d28f3
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-status.test.ts
@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SLACK_ASSISTANT_DEADLINE_ERROR } from 'src/logic-functions/constants/slack-assistant-deadline-error';
+import { runSlackAssistantAgentWithStatus } from 'src/logic-functions/utils/run-slack-assistant-agent-with-status';
+
+const runAgentMock = vi.hoisted(() => vi.fn());
+const startStatusUpdatesMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ runAgent: runAgentMock,
+}));
+
+vi.mock(
+ 'src/logic-functions/utils/start-slack-assistant-status-updates',
+ () => ({
+ startSlackAssistantStatusUpdates: startStatusUpdatesMock,
+ }),
+);
+
+const BASE_INPUT = {
+ agentUniversalIdentifier: 'agent-uid',
+ runAsWorkspaceMemberId: undefined,
+ messages: [{ role: 'user' as const, content: 'hi' }],
+ slackChannelId: 'C1',
+ threadTimestamp: '1700000000.000100',
+};
+
+describe('runSlackAssistantAgentWithStatus', () => {
+ beforeEach(() => {
+ startStatusUpdatesMock.mockReturnValue(() => Promise.resolve());
+ runAgentMock.mockResolvedValue({ result: {}, error: null, success: true });
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should not start the agent or status updates when the deadline has already passed', async () => {
+ const result = await runSlackAssistantAgentWithStatus({
+ ...BASE_INPUT,
+ deadlineAtMs: Date.now() - 1000,
+ });
+
+ expect(result).toEqual({
+ result: null,
+ error: SLACK_ASSISTANT_DEADLINE_ERROR,
+ success: false,
+ });
+ expect(runAgentMock).not.toHaveBeenCalled();
+ expect(startStatusUpdatesMock).not.toHaveBeenCalled();
+ });
+
+ it('should run the agent when the deadline is still ahead', async () => {
+ const result = await runSlackAssistantAgentWithStatus({
+ ...BASE_INPUT,
+ deadlineAtMs: Date.now() + 60_000,
+ });
+
+ expect(result.success).toBe(true);
+ expect(runAgentMock).toHaveBeenCalledOnce();
+ expect(startStatusUpdatesMock).toHaveBeenCalledOnce();
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/race-slack-assistant-agent-deadline.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/race-slack-assistant-agent-deadline.ts
new file mode 100644
index 00000000000..0022a42557c
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/race-slack-assistant-agent-deadline.ts
@@ -0,0 +1,31 @@
+import { type RunAgentResult } from 'twenty-sdk/logic-function';
+
+import { SLACK_ASSISTANT_DEADLINE_ERROR } from 'src/logic-functions/constants/slack-assistant-deadline-error';
+
+export const raceSlackAssistantAgentDeadline = async ({
+ agentRun,
+ deadlineAtMs,
+}: {
+ agentRun: Promise<RunAgentResult>;
+ deadlineAtMs: number;
+}): Promise<RunAgentResult> => {
+ let deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+
+ const deadlineResult = new Promise<RunAgentResult>((resolve) => {
+ deadlineTimer = setTimeout(
+ () =>
+ resolve({
+ result: null,
+ error: SLACK_ASSISTANT_DEADLINE_ERROR,
+ success: false,
+ }),
+ Math.max(deadlineAtMs - Date.now(), 0),
+ );
+ });
+
+ try {
+ return await Promise.race([agentRun, deadlineResult]);
+ } finally {
+ clearTimeout(deadlineTimer);
+ }
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.ts
index 5746d60678f..187bc1ec015 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.ts
@@ -4,7 +4,9 @@ import {
type RunAgentResult,
} from 'twenty-sdk/logic-function';
+import { SLACK_ASSISTANT_DEADLINE_ERROR } from 'src/logic-functions/constants/slack-assistant-deadline-error';
import { type SlackAssistantAgentMessage } from 'src/logic-functions/types/slack-assistant-agent-message.type';
+import { raceSlackAssistantAgentDeadline } from 'src/logic-functions/utils/race-slack-assistant-agent-deadline';
import { startSlackAssistantStatusUpdates } from 'src/logic-functions/utils/start-slack-assistant-status-updates';
type RunSlackAssistantAgentInput = Pick<
@@ -14,6 +16,7 @@ type RunSlackAssistantAgentInput = Pick<
messages: SlackAssistantAgentMessage[];
slackChannelId: string;
threadTimestamp: string;
+ deadlineAtMs: number;
};
export const runSlackAssistantAgentWithStatus = async ({
@@ -22,17 +25,29 @@ export const runSlackAssistantAgentWithStatus = async ({
runAsWorkspaceMemberId,
slackChannelId,
threadTimestamp,
+ deadlineAtMs,
}: RunSlackAssistantAgentInput): Promise<RunAgentResult> => {
+ if (deadlineAtMs - Date.now() <= 0) {
+ return {
+ result: null,
+ error: SLACK_ASSISTANT_DEADLINE_ERROR,
+ success: false,
+ };
+ }
+
const stopStatusUpdates = startSlackAssistantStatusUpdates({
slackChannelId,
threadTimestamp,
});
try {
- return await runAgent({
- agentUniversalIdentifier,
- messages,
- runAsWorkspaceMemberId,
+ return await raceSlackAssistantAgentDeadline({
+ agentRun: runAgent({
+ agentUniversalIdentifier,
+ messages,
+ runAsWorkspaceMemberId,
+ }),
+ deadlineAtMs,
});
} finally {
await stopStatusUpdates();