The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.jsonindex 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.tsnew file mode 100644index 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.tsindex 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-workspacimport { 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.tssimilarity index 56%rename from packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-status.test.tsrename to packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/run-slack-assistant-agent-with-deadline.test.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tssimilarity index 59%rename from packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-status.tsrename to packages/twenty-apps/public/slack/src/logic-functions/utils/run-slack-assistant-agent-with-deadline.tsindex 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.tsindex 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.tsindex 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),);