Remove default Mship execution cutoff and expose Slack agent prerequisites

Author: Sg312

apps/sim/app/api/copilot/chat/stream/route.test.ts

@@ -124,33 +124,43 @@ describe('copilot chat stream replay route', () => {
     })
   })
 
-  it('stops replay polling when run becomes cancelled', async () => {
-    getLatestRunForStream
-      .mockResolvedValueOnce({
-        status: 'active',
-        executionId: 'exec-1',
-        id: 'run-1',
+  it.each([0, 2 * 60 * 60_000])(
+    'delivers cancellation after %i ms of replay',
+    async (elapsedMs) => {
+      const now = Date.now()
+      const clock = vi.spyOn(Date, 'now').mockReturnValue(now)
+      readEvents.mockImplementationOnce(async () => {
+        clock.mockReturnValue(now + elapsedMs)
+        return []
       })
-      .mockResolvedValueOnce({
-        status: 'cancelled',
-        executionId: 'exec-1',
-        id: 'run-1',
-      })
-
-    const response = await GET(
-      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
-    )
+      getLatestRunForStream
+        .mockResolvedValueOnce({
+          status: 'active',
+          executionId: 'exec-1',
+          id: 'run-1',
+        })
+        .mockResolvedValueOnce({
+          status: 'cancelled',
+          executionId: 'exec-1',
+          id: 'run-1',
+        })
+
+      const response = await GET(
+        new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
+      )
 
-    const chunks = await readAllChunks(response)
-    expect(chunks[0]).toBe(': accepted\n\n')
-    expect(chunks.join('')).toContain(
-      JSON.stringify({
-        status: MothershipStreamV1CompletionStatus.cancelled,
-        reason: 'terminal_status',
-      })
-    )
-    expect(getLatestRunForStream).toHaveBeenCalledTimes(2)
-  })
+      const chunks = await readAllChunks(response)
+      expect(chunks[0]).toBe(': accepted\n\n')
+      expect(chunks.join('')).toContain(
+        JSON.stringify({
+          status: MothershipStreamV1CompletionStatus.cancelled,
+          reason: 'terminal_status',
+        })
+      )
+      expect(getLatestRunForStream).toHaveBeenCalledTimes(2)
+      clock.mockRestore()
+    }
+  )
 
   it('emits structured terminal replay error when run metadata disappears', async () => {
     getLatestRunForStream

apps/sim/app/api/copilot/chat/stream/route.ts

@@ -37,13 +37,10 @@ import {
 } from '@/lib/mothership/request/session'
 import { toReplayEnvelope, toStreamBatchEvent } from '@/lib/mothership/request/session/types'
 
-export const maxDuration = 3600
-
 const logger = createLogger('CopilotChatStreamAPI')
 const POLL_INTERVAL_MS = 250
 const POLL_INTERVAL_MAX_MS = 2_000
 const REPLAY_KEEPALIVE_INTERVAL_MS = 15_000
-const MAX_STREAM_MS = 60 * 60 * 1000
 
 function extractCanonicalRequestId(value: unknown): string {
   return typeof value === 'string' && value.length > 0 ? value : ''
@@ -396,7 +393,7 @@ async function handleResumeRequestBody({
       await flushEvents()
 
       let pollDelayMs = POLL_INTERVAL_MS
-      while (!controllerClosed && Date.now() - startTime < MAX_STREAM_MS) {
+      while (!controllerClosed) {
         pollIterations += 1
         const currentRun = await readRun().catch((err) => {
           logger.warn('Failed to poll latest run for stream', {
@@ -419,7 +416,7 @@ async function handleResumeRequestBody({
         const flushed = await flushEvents()
         /* Adaptive tail: 4 Hz only while events are actually flowing; a quiet stream
            decays toward the cap so an attached client doesn't hammer Postgres + Redis
-           at 4 Hz for up to an hour. Any flushed event snaps back to full rate. */
+           at 4 Hz during long runs. Any flushed event snaps back to full rate. */
         pollDelayMs =
           flushed > 0 ? POLL_INTERVAL_MS : Math.min(pollDelayMs * 2, POLL_INTERVAL_MAX_MS)
 
@@ -451,13 +448,6 @@ async function handleResumeRequestBody({
 
         await sleep(pollDelayMs)
       }
-      if (!controllerClosed && Date.now() - startTime >= MAX_STREAM_MS) {
-        emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
-          message: 'The stream recovery timed out before completion.',
-          code: 'resume_timeout',
-          reason: 'timeout',
-        })
-      }
     } catch (error) {
       if (!controllerClosed && !request.signal.aborted) {
         logger.warn('Stream replay failed', {

apps/sim/app/api/mothership/chat/route.ts

@@ -10,8 +10,6 @@ import { handleUnifiedChatPost } from '@/lib/mothership/chat/post'
 import { validateShimEnvelope } from '@/lib/mothership/request/http'
 import { GET as copilotChatGet } from '@/app/api/copilot/chat/queries'
 
-export const maxDuration = 3600
-
 // Unified chat route surface.
 export const GET = withRouteHandler((request: NextRequest) => {
   const validation = mothershipChatGetQuerySchema.safeParse(

apps/sim/app/api/mothership/chat/stream/route.ts

@@ -1,9 +1,7 @@
 import type { NextRequest } from 'next/server'
 import { mothershipChatStreamQuerySchema } from '@/lib/api/contracts/mothership-chats'
 import { validationErrorResponse } from '@/lib/api/server'
-import { GET as copilotStreamGet, maxDuration } from '@/app/api/copilot/chat/stream/route'
-
-export { maxDuration }
+import { GET as copilotStreamGet } from '@/app/api/copilot/chat/stream/route'
 
 export function GET(request: NextRequest) {
   const validation = mothershipChatStreamQuerySchema.safeParse(

apps/sim/app/api/mothership/execute/route.ts

@@ -48,8 +48,6 @@ import {
 import type { ChatContext } from '@/stores/panel'
 import { hasToolId } from '@/tools/tool-ids'
 
-export const maxDuration = 3600
-
 const logger = createLogger('MothershipExecuteAPI')
 const MOTHERSHIP_EXECUTE_STREAM_HEADER = 'x-mothership-execute-stream'
 const MOTHERSHIP_EXECUTE_STREAM_VALUE = 'ndjson'

apps/sim/blocks/blocks/slack.ts

@@ -20,6 +20,7 @@ import {
 } from '@/blocks/utils'
 import type { SlackResponse } from '@/tools/slack/types'
 import { getTrigger } from '@/triggers'
+import { SLACK_AGENT_SCOPES } from '@/triggers/slack/capabilities'
 
 /**
  * Canonical basic/advanced pair for the channel target, shared by the card
@@ -3594,6 +3595,11 @@ export const SlackV2Block: BlockConfig<SlackResponse> = {
   description: 'Manage Slack messages, channels, users, files, Lists, canvases, and Agent Sessions',
   longDescription:
     'Build Slack workflows with messages, conversations, files, reactions, pins, bookmarks, user groups, profiles, Lists, canvases, and Agent Sessions. Operations that need additional app scopes use custom Slack bots. Lists require lists:read/lists:write and a paid Slack plan. Native Sim connections retain their existing permissions. Page through list outputs explicitly.',
+  bestPractices: `${SlackBlock.bestPractices}
+Native agent-session streaming uses a custom Slack bot and a supported trigger event. Enable streamResponse and select the intended outputs in streamOutputs; Sim Chat (mothership) streams its content output. The trigger owns the streamed reply, so another send needs a separate purpose.
+The custom-bot manifest's baseline agent scopes are ${SLACK_AGENT_SCOPES.join(', ')}. Selected capabilities add their required scopes and event subscriptions. Verify the installed app's grants, resource access and event configuration; a saved credential or edited manifest alone does not prove access.
+streamIncludeToolCalls displays tool activity; it does not authorize tool execution. Configure Sim Chat's selected operations and their credentials separately. Choose streamIncludeThinking deliberately for the destination audience.
+Block Kit messages can contain buttons, selects and forms, but interactions require the app's interactivity request URL and the corresponding interaction trigger. Treat message events, button/select callbacks and modal submissions as separate paths. A control's action_id/value correlates work; runtime actor and state checks authorize it.`,
   hideFromToolbar: false,
   sunset: undefined,
   canvasPresentation: {

apps/sim/lib/mothership/auth/application-delegation.ts

@@ -1,7 +1,7 @@
 import type { DelegatedPrincipal, OrganizationDelegatedPrincipal } from '@sim/auth/principal'
 import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/mothership/constants'
 
-/** Keeps delegated authority valid for the full bounded Copilot orchestration lifetime. */
+/** Per-operation authority expires independently of the assistant run lifetime. */
 export const COPILOT_APPLICATION_DELEGATION_TTL_MS = ORCHESTRATION_TIMEOUT_MS
 
 export interface CopilotExecutionContext {

apps/sim/lib/mothership/constants.ts

@@ -10,7 +10,7 @@ export const SIM_AGENT_API_URL =
     ? rawAgentUrl
     : SIM_AGENT_API_URL_DEFAULT
 
-/** Default timeout for the copilot orchestration stream loop (60 min). */
+/** Bounded per-operation credential and permission lifetime; not a total run limit. */
 export const ORCHESTRATION_TIMEOUT_MS = 3_600_000
 
 /**
@@ -26,14 +26,14 @@ export const TOOL_WATCHDOG_DEFAULT_MS = 60_000
  * executions, media/image generation, sandboxed code, deep research). Those
  * tools carry their own inner budgets (plan execution timeouts, sandbox
  * timeouts), so this cap only backstops a true hang and sits above all of
- * them — matching ORCHESTRATION_TIMEOUT_MS so it never undercuts a legal run.
+ * them. This limits one operation, not the entire assistant run.
  */
 export const TOOL_WATCHDOG_LONG_RUNNING_MS = ORCHESTRATION_TIMEOUT_MS
 
 /** Extra slack the resume gate allows past the slowest pending tool's watchdog. */
 export const TOOL_WATCHDOG_RESUME_GRACE_MS = 30_000
 
-/** Timeout for the client-side streaming response handler (60 min). */
+/** Maximum wait for one client-executed workflow tool (60 min). */
 export const STREAM_TIMEOUT_MS = 3_600_000
 
 /**

apps/sim/lib/mothership/request/go/stream.test.ts

@@ -179,6 +179,7 @@ describe('copilot go stream helpers', () => {
   })
 
   afterEach(() => {
+    vi.useRealTimers()
     vi.unstubAllGlobals()
   })
 
@@ -423,6 +424,41 @@ describe('copilot go stream helpers', () => {
     }
   )
 
+  it('keeps a healthy stream open beyond an hour when no deadline was requested', async () => {
+    vi.useFakeTimers()
+    let streamController: ReadableStreamDefaultController<Uint8Array> | undefined
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(
+        new ReadableStream<Uint8Array>({
+          start(controller) {
+            streamController = controller
+          },
+        }),
+        { headers: { 'content-type': 'text/event-stream' } }
+      )
+    )
+    const context = createStreamingContext()
+    const pending = runStreamLoop(
+      'https://example.com/mothership/stream',
+      {},
+      context,
+      turnScopedExecContext(),
+      { flushAfterEvent: false }
+    )
+    await vi.advanceTimersByTimeAsync(2 * 60 * 60_000)
+    expect(context.streamComplete).toBe(false)
+    expect(context.errors).toEqual([])
+    streamController?.enqueue(
+      new TextEncoder().encode(
+        'data: {"v":1,"type":"complete","seq":1,"ts":"","stream":{"streamId":"s"},"payload":{"status":"complete"}}\n\n'
+      )
+    )
+    streamController?.close()
+    await pending
+    expect(context.errors).toEqual([])
+    vi.useRealTimers()
+  })
+
   it('bounds response-header waits without classifying the deadline as user Stop', async () => {
     vi.mocked(fetch).mockImplementationOnce(
       (_url, options) =>

apps/sim/lib/mothership/request/go/stream.ts

@@ -1,7 +1,6 @@
 import { type Context, SpanStatusCode } from '@opentelemetry/api'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
-import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/mothership/constants'
 import { MothershipStreamV1EventType } from '@/lib/mothership/generated/mothership-stream-v1'
 import { CopilotSseCloseReason } from '@/lib/mothership/generated/trace-attribute-values-v1'
 import { TraceAttr } from '@/lib/mothership/generated/trace-attributes-v1'
@@ -125,9 +124,13 @@ export async function runStreamLoop(
   execContext: ExecutionContext,
   options: StreamLoopOptions
 ): Promise<void> {
-  const { timeout = ORCHESTRATION_TIMEOUT_MS, abortSignal } = options
-  const timeoutSignal = AbortSignal.timeout(Math.ceil(timeout))
-  const requestSignal = abortSignal ? AbortSignal.any([abortSignal, timeoutSignal]) : timeoutSignal
+  const { timeout, abortSignal } = options
+  const timeoutSignal = timeout === undefined ? undefined : AbortSignal.timeout(Math.ceil(timeout))
+  const requestSignal = timeoutSignal
+    ? abortSignal
+      ? AbortSignal.any([abortSignal, timeoutSignal])
+      : timeoutSignal
+    : abortSignal
   const filePreviewAdapterState = createFilePreviewAdapterState()
   const attemptedInlineImages = new Set<string>()
 
@@ -262,12 +265,15 @@ export async function runStreamLoop(
     },
   }
 
-  const timeoutId = setTimeout(() => {
-    context.errors.push('Request timed out')
-    context.streamComplete = true
-    endedOn = CopilotSseCloseReason.Timeout
-    reader.cancel().catch(() => {})
-  }, timeout)
+  const timeoutId =
+    timeout === undefined
+      ? undefined
+      : setTimeout(() => {
+          context.errors.push('Request timed out')
+          context.streamComplete = true
+          endedOn = CopilotSseCloseReason.Timeout
+          reader.cancel().catch(() => {})
+        }, timeout)
 
   try {
     await processSSEStream(reader, abortSignal, async (raw) => {