Skip to content

The open alternative to Salesforce, designed for AI.

feat(slack): show the thinking status before the assistant context lookups (#25676)

Abdul Rahman940b485468d1
diff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.json
index e6385ad0cd9..0b8009ce522 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.1",
+ "version": "1.0.2",
"description": "Slack assistant and workflow steps for Twenty",
"license": "MIT",
"engines": {
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
new file mode 100644
index 00000000000..f056716c32e
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/__tests__/slack-assistant-worker.test.ts
@@ -0,0 +1,241 @@
+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';
+
+const {
+ callLog,
+ coreApiClientMock,
+ updateSlackAssistantRequestMock,
+ fetchSlackAssistantContextMock,
+ fetchWorkspaceBaseUrlsMock,
+ resolveSlackRunAsForRequestMock,
+ runSlackAssistantAgentWithDeadlineMock,
+ slackPostMessageHandlerMock,
+ 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(),
+ slackPostMessageHandlerMock: 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/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/handlers/slack-post-message-handler', () => ({
+ slackPostMessageHandler: slackPostMessageHandlerMock,
+}));
+
+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,
+};
+
+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', () => {
+ 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.' } };
+ });
+ slackPostMessageHandlerMock.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');
+ });
+
+ const result = await slackAssistantWorkerHandler(buildEvent());
+
+ 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(result).toEqual({ skipped: true, reason: 'Request is not pending' });
+ expect(startSlackAssistantStatusUpdatesMock).not.toHaveBeenCalled();
+ });
+});
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 def15fd652a..ef3564a140c 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
@@ -27,8 +27,9 @@ import { fetchWorkspaceBaseUrls } from 'src/logic-functions/utils/fetch-workspac
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 { resolveSlackRunAsForRequest } from 'src/logic-functions/utils/resolve-slack-run-as-for-request';
-import { runSlackAssistantAgentWithStatus } from 'src/logic-functions/utils/run-slack-assistant-agent-with-status';
+import { runSlackAssistantAgentWithDeadline } from 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline';
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';
const SLACK_ASSISTANT_REQUEST_OBJECT_NAME = 'slackAssistantRequest';
@@ -82,6 +83,11 @@ export const slackAssistantWorkerHandler = async (
parentMessageTimestamp,
};
+ const stopStatusUpdates = startSlackAssistantStatusUpdates({
+ slackChannelId,
+ threadTimestamp: parentMessageTimestamp,
+ });
+
try {
const [
{
@@ -129,7 +135,7 @@ export const slackAssistantWorkerHandler = async (
0,
);
- const agentResult = await runSlackAssistantAgentWithStatus({
+ const agentResult = await runSlackAssistantAgentWithDeadline({
agentUniversalIdentifier: SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER,
runAsWorkspaceMemberId,
messages: buildSlackAssistantMessages({
@@ -140,10 +146,8 @@ export const slackAssistantWorkerHandler = async (
timeoutSeconds: agentBudgetRemainingSeconds,
workspaceBaseUrl: workspaceBaseUrls[0],
}),
- slackChannelId,
- threadTimestamp: parentMessageTimestamp,
deadlineAtMs: agentDeadlineAtMs,
- });
+ }).finally(() => stopStatusUpdates());
if (!agentResult.success) {
return await finishSlackAssistantRequestWithFailure({
@@ -207,6 +211,8 @@ export const slackAssistantWorkerHandler = async (
return { done: true };
} catch (error) {
+ await stopStatusUpdates();
+
return await finishSlackAssistantRequestWithFailure({
...failureContext,
errorMessage:
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-deadline.test.ts
similarity index 56%
rename from packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-status.test.ts
rename to packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-deadline.test.ts
index f4a508d28f3..d7872ecba16 100644
--- 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-deadline.test.ts
@@ -1,33 +1,22 @@
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';
+import { runSlackAssistantAgentWithDeadline } from 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline';
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', () => {
+describe('runSlackAssistantAgentWithDeadline', () => {
beforeEach(() => {
- startStatusUpdatesMock.mockReturnValue(() => Promise.resolve());
runAgentMock.mockResolvedValue({ result: {}, error: null, success: true });
});
@@ -35,8 +24,8 @@ describe('runSlackAssistantAgentWithStatus', () => {
vi.clearAllMocks();
});
- it('should not start the agent or status updates when the deadline has already passed', async () => {
- const result = await runSlackAssistantAgentWithStatus({
+ it('should not start the agent when the deadline has already passed', async () => {
+ const result = await runSlackAssistantAgentWithDeadline({
...BASE_INPUT,
deadlineAtMs: Date.now() - 1000,
});
@@ -47,17 +36,15 @@ describe('runSlackAssistantAgentWithStatus', () => {
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({
+ const result = await runSlackAssistantAgentWithDeadline({
...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/__tests__/start-slack-assistant-status-updates.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/start-slack-assistant-status-updates.test.ts
index 33aa26e03f1..72c2a2df099 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/start-slack-assistant-status-updates.test.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/start-slack-assistant-status-updates.test.ts
@@ -6,9 +6,15 @@ import {
} from 'src/logic-functions/constants/slack-assistant-status-steps';
import { startSlackAssistantStatusUpdates } from 'src/logic-functions/utils/start-slack-assistant-status-updates';
-const setSlackAssistantStatusMock = vi.hoisted(() =>
- vi.fn().mockResolvedValue(undefined),
-);
+const { resolveBestEffortSlackClientMock, setSlackAssistantStatusMock } =
+ vi.hoisted(() => ({
+ resolveBestEffortSlackClientMock: vi.fn(),
+ setSlackAssistantStatusMock: vi.fn().mockResolvedValue(undefined),
+ }));
+
+vi.mock('src/logic-functions/utils/resolve-best-effort-slack-client', () => ({
+ resolveBestEffortSlackClient: resolveBestEffortSlackClientMock,
+}));
vi.mock('src/logic-functions/utils/set-slack-assistant-status', () => ({
setSlackAssistantStatus: setSlackAssistantStatusMock,
@@ -19,9 +25,12 @@ const THREAD = {
threadTimestamp: '1700000000.000100',
};
+const SLACK_CLIENT = { assistant: {} };
+
describe('startSlackAssistantStatusUpdates', () => {
beforeEach(() => {
vi.useFakeTimers();
+ resolveBestEffortSlackClientMock.mockResolvedValue(SLACK_CLIENT);
});
afterEach(() => {
@@ -29,18 +38,21 @@ describe('startSlackAssistantStatusUpdates', () => {
vi.clearAllMocks();
});
- it('should set the initial status immediately', () => {
+ it('should set the initial status as soon as the client resolves', async () => {
const stop = startSlackAssistantStatusUpdates(THREAD);
+ await vi.advanceTimersByTimeAsync(0);
+
expect(setSlackAssistantStatusMock).toHaveBeenCalledExactlyOnceWith({
...THREAD,
+ client: SLACK_CLIENT,
status: SLACK_ASSISTANT_INITIAL_STATUS,
});
- return stop();
+ await stop();
});
- it('should walk through every status step in order', async () => {
+ it('should resolve the Slack client once for every refresh', async () => {
const stop = startSlackAssistantStatusUpdates(THREAD);
await vi.runAllTimersAsync();
@@ -53,6 +65,7 @@ describe('startSlackAssistantStatusUpdates', () => {
SLACK_ASSISTANT_INITIAL_STATUS,
...SLACK_ASSISTANT_STATUS_STEPS.map((step) => step.text),
]);
+ expect(resolveBestEffortSlackClientMock).toHaveBeenCalledOnce();
await stop();
});
@@ -60,12 +73,43 @@ describe('startSlackAssistantStatusUpdates', () => {
it('should stop future updates once stopped', async () => {
const stop = startSlackAssistantStatusUpdates(THREAD);
+ await vi.advanceTimersByTimeAsync(0);
await stop();
vi.runAllTimers();
expect(setSlackAssistantStatusMock).toHaveBeenCalledTimes(1);
});
+ it('should drop a refresh whose client lookup was still pending when stopped', async () => {
+ let resolveClient: (value: unknown) => void = () => undefined;
+
+ resolveBestEffortSlackClientMock.mockReturnValue(
+ new Promise((resolve) => {
+ resolveClient = resolve;
+ }),
+ );
+
+ const stop = startSlackAssistantStatusUpdates(THREAD);
+ const stopped = stop();
+
+ resolveClient(SLACK_CLIENT);
+ await stopped;
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(setSlackAssistantStatusMock).not.toHaveBeenCalled();
+ });
+
+ it('should skip every refresh when Slack is not connected', async () => {
+ resolveBestEffortSlackClientMock.mockResolvedValue(undefined);
+
+ const stop = startSlackAssistantStatusUpdates(THREAD);
+
+ await vi.runAllTimersAsync();
+ await stop();
+
+ expect(setSlackAssistantStatusMock).not.toHaveBeenCalled();
+ });
+
it('should keep every gap between refreshes under the 2-minute status expiry', () => {
const stepTimes = [
0,
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-best-effort-slack-client.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-best-effort-slack-client.ts
new file mode 100644
index 00000000000..a02358792dd
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-best-effort-slack-client.ts
@@ -0,0 +1,22 @@
+import { type WebClient } from '@slack/web-api';
+
+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';
+
+const BEST_EFFORT_TIMEOUT_MS = 5000;
+
+export const resolveBestEffortSlackClient = async (
+ description: string,
+): Promise<WebClient | undefined> => {
+ const slackClientResult = await getSlackClient({
+ retryConfig: { retries: 0 },
+ timeout: BEST_EFFORT_TIMEOUT_MS,
+ });
+
+ if (!slackClientResult.success) {
+ console.warn(`[slack] ${description} skipped: ${slackClientResult.error}`);
+
+ return undefined;
+ }
+
+ return slackClientResult.client;
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call-with-client.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call-with-client.ts
new file mode 100644
index 00000000000..a5a8bcd835e
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call-with-client.ts
@@ -0,0 +1,15 @@
+import { type WebClient } from '@slack/web-api';
+
+export const runBestEffortSlackCallWithClient = async (
+ description: string,
+ client: WebClient,
+ call: (client: WebClient) => Promise<unknown>,
+): Promise<void> => {
+ try {
+ await call(client);
+ } catch (error) {
+ console.warn(
+ `[slack] ${description} failed: ${error instanceof Error ? error.message : String(error)}`,
+ );
+ }
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call.ts
index 7a50a2f9ff2..36902734fd8 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/run-best-effort-slack-call.ts
@@ -1,29 +1,18 @@
import { type WebClient } from '@slack/web-api';
+import { isDefined } from 'twenty-sdk/utils';
-import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';
-
-const BEST_EFFORT_TIMEOUT_MS = 5000;
+import { resolveBestEffortSlackClient } from 'src/logic-functions/utils/resolve-best-effort-slack-client';
+import { runBestEffortSlackCallWithClient } from 'src/logic-functions/utils/run-best-effort-slack-call-with-client';
export const runBestEffortSlackCall = async (
description: string,
call: (client: WebClient) => Promise<unknown>,
): Promise<void> => {
- const slackClientResult = await getSlackClient({
- retryConfig: { retries: 0 },
- timeout: BEST_EFFORT_TIMEOUT_MS,
- });
-
- if (!slackClientResult.success) {
- console.warn(`[slack] ${description} skipped: ${slackClientResult.error}`);
+ const client = await resolveBestEffortSlackClient(description);
+ if (!isDefined(client)) {
return;
}
- try {
- await call(slackClientResult.client);
- } catch (error) {
- console.warn(
- `[slack] ${description} failed: ${error instanceof Error ? error.message : String(error)}`,
- );
- }
+ await runBestEffortSlackCallWithClient(description, client, call);
};
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-deadline.ts
similarity index 59%
rename from packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.ts
rename to packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-deadline.ts
index 187bc1ec015..d61560515c5 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-deadline.ts
@@ -7,24 +7,19 @@ import {
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<
RunAgentInput,
'agentUniversalIdentifier' | 'runAsWorkspaceMemberId'
> & {
messages: SlackAssistantAgentMessage[];
- slackChannelId: string;
- threadTimestamp: string;
deadlineAtMs: number;
};
-export const runSlackAssistantAgentWithStatus = async ({
+export const runSlackAssistantAgentWithDeadline = async ({
agentUniversalIdentifier,
messages,
runAsWorkspaceMemberId,
- slackChannelId,
- threadTimestamp,
deadlineAtMs,
}: RunSlackAssistantAgentInput): Promise<RunAgentResult> => {
if (deadlineAtMs - Date.now() <= 0) {
@@ -35,21 +30,12 @@ export const runSlackAssistantAgentWithStatus = async ({
};
}
- const stopStatusUpdates = startSlackAssistantStatusUpdates({
- slackChannelId,
- threadTimestamp,
+ return await raceSlackAssistantAgentDeadline({
+ agentRun: runAgent({
+ agentUniversalIdentifier,
+ messages,
+ runAsWorkspaceMemberId,
+ }),
+ deadlineAtMs,
});
-
- try {
- return await raceSlackAssistantAgentDeadline({
- agentRun: runAgent({
- agentUniversalIdentifier,
- messages,
- runAsWorkspaceMemberId,
- }),
- deadlineAtMs,
- });
- } finally {
- await stopStatusUpdates();
- }
};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/set-slack-assistant-status.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/set-slack-assistant-status.ts
index fcba24ab963..cdb5e2f675b 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/set-slack-assistant-status.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/set-slack-assistant-status.ts
@@ -1,15 +1,19 @@
-import { runBestEffortSlackCall } from 'src/logic-functions/utils/run-best-effort-slack-call';
+import { type WebClient } from '@slack/web-api';
+
+import { runBestEffortSlackCallWithClient } from 'src/logic-functions/utils/run-best-effort-slack-call-with-client';
export const setSlackAssistantStatus = async ({
+ client,
slackChannelId,
threadTimestamp,
status,
}: {
+ client: WebClient;
slackChannelId: string;
threadTimestamp: string;
status: string;
}): Promise<void> =>
- runBestEffortSlackCall('assistant.threads.setStatus', (client) =>
+ runBestEffortSlackCallWithClient('assistant.threads.setStatus', client, () =>
client.assistant.threads.setStatus({
channel_id: slackChannelId,
thread_ts: threadTimestamp,
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/start-slack-assistant-status-updates.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/start-slack-assistant-status-updates.ts
index 1c54bdc2e47..9f5b437c569 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/start-slack-assistant-status-updates.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/start-slack-assistant-status-updates.ts
@@ -2,6 +2,9 @@ import {
SLACK_ASSISTANT_INITIAL_STATUS,
SLACK_ASSISTANT_STATUS_STEPS,
} from 'src/logic-functions/constants/slack-assistant-status-steps';
+import { isDefined } from 'twenty-sdk/utils';
+
+import { resolveBestEffortSlackClient } from 'src/logic-functions/utils/resolve-best-effort-slack-client';
import { setSlackAssistantStatus } from 'src/logic-functions/utils/set-slack-assistant-status';
const STATUS_SHUTDOWN_TIMEOUT_MS = 5000;
@@ -14,11 +17,27 @@ export const startSlackAssistantStatusUpdates = ({
threadTimestamp: string;
}): (() => Promise<void>) => {
let isStopped = false;
- let pendingUpdate: Promise<void> = setSlackAssistantStatus({
- slackChannelId,
- threadTimestamp,
- status: SLACK_ASSISTANT_INITIAL_STATUS,
- });
+
+ const slackClient = resolveBestEffortSlackClient(
+ 'assistant.threads.setStatus',
+ );
+
+ const sendStatus = async (status: string): Promise<void> => {
+ const client = await slackClient;
+
+ if (isStopped || !isDefined(client)) {
+ return;
+ }
+
+ await setSlackAssistantStatus({
+ client,
+ slackChannelId,
+ threadTimestamp,
+ status,
+ });
+ };
+
+ let pendingUpdate = sendStatus(SLACK_ASSISTANT_INITIAL_STATUS);
const timers = SLACK_ASSISTANT_STATUS_STEPS.map((step) =>
setTimeout(() => {
@@ -26,13 +45,7 @@ export const startSlackAssistantStatusUpdates = ({
return;
}
- pendingUpdate = pendingUpdate.then(() =>
- setSlackAssistantStatus({
- slackChannelId,
- threadTimestamp,
- status: step.text,
- }),
- );
+ pendingUpdate = pendingUpdate.then(() => sendStatus(step.text));
}, step.afterSeconds * 1000),
);