fix(slack): polish trigger response streaming

Author: TheodoreSpeaks

apps/docs/content/docs/integrations/slack.mdx

@@ -32,9 +32,10 @@ In Sim, the Slack integration enables your agents to programmatically interact w
 
 Custom-bot Slack triggers can stream workflow outputs directly back into the conversation that started a run. Enable **Stream response to Slack** on a Message, App Mention, or Assistant Thread Started trigger, then select the outputs to deliver.
 
-- A selected Agent output streams as it is generated. Intermediate pre-tool turns are held back so only the final answer is appended.
+- A selected Agent output streams immediately as it is generated. If the Agent later calls a tool, any pre-tool commentary already streamed remains visible.
 - A selected non-streaming block output is sent when that block invocation completes.
 - Loop and parallel invocations each create their own Slack response.
+- The response status label defaults to `Running` and can be customized in the trigger's advanced settings.
 - Optional thinking and tool-call updates appear as Slack tasks in a timeline or plan.
 - Slack Agent Sessions remain in processing state for the run, return to active when it finishes, and the native Slack stop button cancels active workflow executions.
 
@@ -2007,6 +2008,7 @@ Trigger from Slack events (mentions, messages, reactions)
 | `streamResponse` | boolean | No | Stream selected workflow outputs into the Slack conversation that started this run. Custom bots only. |
 | `streamOutputs` | workflow-output-selector | No | Each selected block invocation creates its own Slack response. Agent outputs stream live; other outputs are sent when the block completes. |
 | `streamIncludeThinking` | boolean | No | Show agent thinking as Slack task updates while the response is generated. |
+| `streamTaskTitle` | string | No | The status Slack shows while each selected response is being produced. |
 | `streamIncludeToolCalls` | boolean | No | Show tool execution lifecycle as Slack task updates. |
 | `streamTaskDisplayMode` | string | No | Choose how Slack displays thinking and tool progress. |
 | `source` | string | No | Restrict to direct messages, public channels, or private channels. Leave empty to match any. |

apps/sim/lib/webhooks/slack-execution-stream.test.ts

@@ -48,6 +48,7 @@ const BASE_CONFIG: SlackStreamResponseConfig = {
   outputConfigs: [{ blockId: 'agent', path: 'content' }],
   includeThinking: true,
   includeToolCalls: true,
+  taskTitle: 'Running',
   taskDisplayMode: 'plan',
 }
 
@@ -67,6 +68,22 @@ function createByteStream(text = ''): ReadableStream<Uint8Array> {
   })
 }
 
+function createOpenByteStream(): { stream: ReadableStream<Uint8Array>; close: () => void } {
+  let closeStream: (() => void) | undefined
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      closeStream = () => controller.close()
+    },
+  })
+  return {
+    stream,
+    close: () => {
+      if (!closeStream) throw new Error('Test stream was not initialized')
+      closeStream()
+    },
+  }
+}
+
 async function createController(
   config: SlackStreamResponseConfig = BASE_CONFIG,
   triggerInput: Record<string, unknown> = {
@@ -106,8 +123,8 @@ describe('SlackExecutionStreamController', () => {
     const { controller } = await createController()
     const events: AgentStreamEvent[] = [
       { type: 'thinking_delta', text: 'Checking context' },
-      { type: 'tool_call_start', id: 'tool-1', name: 'Search' },
-      { type: 'tool_call_end', id: 'tool-1', name: 'Search', status: 'success' },
+      { type: 'tool_call_start', id: 'tool-1', name: 'slack_send_message' },
+      { type: 'tool_call_end', id: 'tool-1', name: 'slack_send_message', status: 'success' },
       { type: 'text_delta', text: 'Hello ', turn: 'pending' },
       { type: 'text_delta', text: 'world', turn: 'pending' },
       { type: 'turn_end', turn: 'final' },
@@ -153,7 +170,7 @@ describe('SlackExecutionStreamController', () => {
         {
           type: 'task_update',
           id: 'sim-execution-1-4',
-          title: 'Generating agent',
+          title: 'Running',
           status: 'in_progress',
         },
       ],
@@ -166,11 +183,16 @@ describe('SlackExecutionStreamController', () => {
         expect.objectContaining({ type: 'task_update', title: 'Thinking', status: 'complete' }),
         expect.objectContaining({
           type: 'task_update',
-          title: 'Search',
+          title: 'Slack Send Message',
           status: 'in_progress',
         }),
-        expect.objectContaining({ type: 'task_update', title: 'Search', status: 'complete' }),
-        { type: 'markdown_text', text: 'Hello world' },
+        expect.objectContaining({
+          type: 'task_update',
+          title: 'Slack Send Message',
+          status: 'complete',
+        }),
+        { type: 'markdown_text', text: 'Hello ' },
+        { type: 'markdown_text', text: 'world' },
         expect.objectContaining({
           type: 'task_update',
           id: 'sim-execution-1-4',
@@ -211,6 +233,36 @@ describe('SlackExecutionStreamController', () => {
     )
   })
 
+  it('appends pending answer text before the model turn is classified', async () => {
+    const { controller } = await createController()
+    const { stream, close } = createOpenByteStream()
+    const streaming = controller.callbacks.onStream?.({
+      blockId: 'agent',
+      executionOrder: 5,
+      stream,
+      streamFormat: 'text',
+      clientStreamTransformed: false,
+      subscribe: ({ onEvent }) => {
+        void onEvent({ type: 'text_delta', text: 'Once upon a time', turn: 'pending' })
+        return vi.fn()
+      },
+    })
+
+    await vi.waitFor(() => {
+      expect(mockAppendSlackAgentStream).toHaveBeenCalledWith(
+        'xoxb-token',
+        'C123',
+        '1700000001.000002',
+        [{ type: 'markdown_text', text: 'Once upon a time' }],
+        undefined
+      )
+    })
+    expect(mockStopSlackAgentStream).not.toHaveBeenCalled()
+
+    close()
+    await streaming
+  })
+
   it('sends selected non-streaming outputs after block completion', async () => {
     const config: SlackStreamResponseConfig = {
       ...BASE_CONFIG,

apps/sim/lib/webhooks/slack-execution-stream.ts

@@ -1,6 +1,7 @@
 import { getErrorMessage } from '@sim/utils/errors'
 import { isRecordLike } from '@sim/utils/object'
 import { truncate } from '@sim/utils/string'
+import { humanizeToolName } from '@/lib/copilot/tools/tool-display'
 import type { LoggingSession } from '@/lib/logs/execution/logging-session'
 import { getSlackBotCredential } from '@/lib/oauth/credential-service'
 import { pluckByPath } from '@/lib/table/pluck'
@@ -25,7 +26,7 @@ import type { BlockCompletionCallbackData, ExecutionCallbacks } from '@/executor
 import type { ExecutionResult, StreamingExecution } from '@/executor/types'
 import type { AgentStreamEvent } from '@/providers/stream-events'
 
-const TEXT_FLUSH_SIZE = 512
+const TEXT_FLUSH_SIZE = 128
 const SLACK_MARKDOWN_LIMIT = 12_000
 const TASK_TEXT_LIMIT = 256
 
@@ -104,7 +105,6 @@ class SlackInvocationStream {
   private channel?: string
   private ts?: string
   private answerBuffer = ''
-  private pendingTurn = ''
   private fullAnswer = ''
   private thinking = ''
   private emittedAnswer = false
@@ -135,7 +135,7 @@ class SlackInvocationStream {
         {
           type: 'task_update',
           id: this.taskId,
-          title: truncate(this.title, TASK_TEXT_LIMIT),
+          title: this.title,
           status: 'in_progress',
         },
       ],
@@ -166,7 +166,7 @@ class SlackInvocationStream {
     if (!text) return
     this.fullAnswer += text
     this.answerBuffer += text
-    await this.flushAnswer(force)
+    await this.flushAnswer(force || !this.emittedAnswer)
   }
 
   private async flushThinking(): Promise<void> {
@@ -190,16 +190,13 @@ class SlackInvocationStream {
     return this.enqueue(async () => {
       switch (event.type) {
         case 'text_delta':
-          if (event.turn === 'pending') {
-            this.pendingTurn += event.text
-          } else if (event.turn !== 'intermediate') {
+          if (event.turn !== 'intermediate') {
             await this.appendAnswer(event.text)
           }
           return
         case 'turn_end':
           await this.flushThinking()
-          if (event.turn === 'final') await this.appendAnswer(this.pendingTurn, true)
-          this.pendingTurn = ''
+          await this.flushAnswer(true)
           return
         case 'thinking_delta':
           if (this.config.includeThinking) this.thinking += event.text
@@ -211,7 +208,7 @@ class SlackInvocationStream {
               {
                 type: 'task_update',
                 id: `${this.taskId}-tool-${event.id}`,
-                title: truncate(event.name, TASK_TEXT_LIMIT),
+                title: truncate(humanizeToolName(event.name), TASK_TEXT_LIMIT),
                 status: 'in_progress',
               },
             ])
@@ -223,7 +220,7 @@ class SlackInvocationStream {
               {
                 type: 'task_update',
                 id: `${this.taskId}-tool-${event.id}`,
-                title: truncate(event.name, TASK_TEXT_LIMIT),
+                title: truncate(humanizeToolName(event.name), TASK_TEXT_LIMIT),
                 status: event.status === 'success' ? 'complete' : 'error',
               },
             ])
@@ -251,7 +248,7 @@ class SlackInvocationStream {
         {
           type: 'task_update',
           id: this.taskId,
-          title: truncate(this.title, TASK_TEXT_LIMIT),
+          title: this.title,
           status: 'complete',
         },
       ])
@@ -267,7 +264,7 @@ class SlackInvocationStream {
         {
           type: 'task_update',
           id: this.taskId,
-          title: truncate(this.title, TASK_TEXT_LIMIT),
+          title: this.title,
           status: 'complete',
         },
       ])
@@ -297,8 +294,8 @@ export class SlackExecutionStreamController {
     )
     this.callbacks = {
       onStream: (stream) => this.onStream(stream),
-      onBlockComplete: (blockId, blockName, _blockType, data) =>
-        this.onBlockComplete(blockId, blockName, data),
+      onBlockComplete: (blockId, _blockName, _blockType, data) =>
+        this.onBlockComplete(blockId, data),
     }
   }
 
@@ -382,7 +379,7 @@ export class SlackExecutionStreamController {
         this.target,
         this.options.config,
         `sim-${this.options.executionId}-${stream.executionOrder}`,
-        `Generating ${stream.blockId}`,
+        this.options.config.taskTitle,
         (text) => this.projectLiveText(text, stream.displayResolvedSecretTraceProvenance),
         (text) => this.projectFinalText(text, stream.displayResolvedSecretTraceProvenance),
         this.options.abortSignal
@@ -416,11 +413,7 @@ export class SlackExecutionStreamController {
     }
   }
 
-  private async onBlockComplete(
-    blockId: string,
-    blockName: string,
-    data: BlockCompletionCallbackData
-  ): Promise<void> {
+  private async onBlockComplete(blockId: string, data: BlockCompletionCallbackData): Promise<void> {
     try {
       const selected = this.selectedForBlock(blockId)
       if (selected.length === 0) return
@@ -446,7 +439,7 @@ export class SlackExecutionStreamController {
         this.target,
         this.options.config,
         `sim-${this.options.executionId}-${data.executionOrder}`,
-        blockName,
+        this.options.config.taskTitle,
         async (value) => value,
         async (value) => value,
         this.options.abortSignal

apps/sim/lib/webhooks/slack-stream-config.test.ts

@@ -16,6 +16,7 @@ describe('Slack stream response config', () => {
       streamOutputs: ['block-1_content', 'block-2_result.value'],
       streamIncludeThinking: true,
       streamIncludeToolCalls: false,
+      streamTaskTitle: '  Working  ',
       streamTaskDisplayMode: 'plan',
     }
     const normalized = normalizeSlackStreamResponseConfig(providerConfig)
@@ -29,11 +30,45 @@ describe('Slack stream response config', () => {
       ],
       includeThinking: true,
       includeToolCalls: false,
+      taskTitle: 'Working',
       taskDisplayMode: 'plan',
     })
     expect(readSlackStreamResponseConfig(providerConfig)).toEqual(normalized)
     expect(providerConfig.streamResponse).toBeUndefined()
     expect(providerConfig.streamOutputs).toBeUndefined()
+    expect(providerConfig.streamTaskTitle).toBeUndefined()
+  })
+
+  it('defaults the response status label to Running and rejects invalid labels', () => {
+    expect(
+      normalizeSlackStreamResponseConfig({
+        eventType: 'message',
+        streamResponse: true,
+        streamOutputs: ['block_content'],
+      })?.taskTitle
+    ).toBe('Running')
+    expect(() =>
+      normalizeSlackStreamResponseConfig({
+        eventType: 'message',
+        streamResponse: true,
+        streamOutputs: ['block_content'],
+        streamTaskTitle: '   ',
+      })
+    ).toThrow('status label is required')
+  })
+
+  it('upgrades persisted configs created before response status labels existed', () => {
+    expect(
+      readSlackStreamResponseConfig({
+        streamResponseConfig: {
+          enabled: true,
+          outputConfigs: [{ blockId: 'block', path: 'content' }],
+          includeThinking: false,
+          includeToolCalls: true,
+          taskDisplayMode: 'timeline',
+        },
+      })?.taskTitle
+    ).toBe('Running')
   })
 
   it('rejects non-reply events and malformed output selectors', () => {

apps/sim/lib/webhooks/slack-stream-config.ts

@@ -16,9 +16,12 @@ export interface SlackStreamResponseConfig {
   outputConfigs: SlackStreamOutputConfig[]
   includeThinking: boolean
   includeToolCalls: boolean
+  taskTitle: string
   taskDisplayMode: 'timeline' | 'plan'
 }
 
+const SLACK_TASK_TITLE_LIMIT = 256
+
 function parseOutputSelector(selector: string): SlackStreamOutputConfig {
   const separatorIndex = selector.indexOf('_')
   if (separatorIndex <= 0 || separatorIndex === selector.length - 1) {
@@ -57,12 +60,26 @@ export function normalizeSlackStreamResponseConfig(
   if (taskDisplayMode !== 'timeline' && taskDisplayMode !== 'plan') {
     throw new Error('Slack stream task display mode must be timeline or plan')
   }
+  const rawTaskTitle = providerConfig.streamTaskTitle ?? 'Running'
+  if (typeof rawTaskTitle !== 'string') {
+    throw new Error('Slack stream response status label must be a string')
+  }
+  const taskTitle = rawTaskTitle.trim()
+  if (!taskTitle) {
+    throw new Error('Slack stream response status label is required')
+  }
+  if (taskTitle.length > SLACK_TASK_TITLE_LIMIT) {
+    throw new Error(
+      `Slack stream response status label must be ${SLACK_TASK_TITLE_LIMIT} characters or fewer`
+    )
+  }
 
   return {
     enabled: true,
     outputConfigs: selectors.map(parseOutputSelector),
     includeThinking: providerConfig.streamIncludeThinking === true,
     includeToolCalls: providerConfig.streamIncludeToolCalls !== false,
+    taskTitle,
     taskDisplayMode,
   }
 }
@@ -91,6 +108,13 @@ export function readSlackStreamResponseConfig(
   if (typeof value.includeThinking !== 'boolean' || typeof value.includeToolCalls !== 'boolean') {
     throw new Error('Persisted Slack stream visibility settings are invalid')
   }
+  const taskTitle = value.taskTitle === undefined ? 'Running' : value.taskTitle
+  if (typeof taskTitle !== 'string' || !taskTitle.trim()) {
+    throw new Error('Persisted Slack stream response status label is invalid')
+  }
+  if (taskTitle.length > SLACK_TASK_TITLE_LIMIT) {
+    throw new Error('Persisted Slack stream response status label is too long')
+  }
   if (value.taskDisplayMode !== 'timeline' && value.taskDisplayMode !== 'plan') {
     throw new Error('Persisted Slack stream task display mode is invalid')
   }
@@ -99,6 +123,7 @@ export function readSlackStreamResponseConfig(
     outputConfigs,
     includeThinking: value.includeThinking,
     includeToolCalls: value.includeToolCalls,
+    taskTitle,
     taskDisplayMode: value.taskDisplayMode,
   }
 }
@@ -122,5 +147,6 @@ export function replaceSlackStreamAuthoringConfig(
   providerConfig.streamOutputs = undefined
   providerConfig.streamIncludeThinking = undefined
   providerConfig.streamIncludeToolCalls = undefined
+  providerConfig.streamTaskTitle = undefined
   providerConfig.streamTaskDisplayMode = undefined
 }