fix(mothership): tool call loop

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

@@ -346,7 +346,6 @@ export async function POST(req: NextRequest) {
           goRoute: '/api/copilot',
           autoExecuteTools: true,
           interactive: true,
-          promptForToolApproval: false,
           onComplete: async (result: OrchestratorResult) => {
             if (!actualChatId) return
 
@@ -365,16 +364,25 @@ export async function POST(req: NextRequest) {
                 const stored: Record<string, unknown> = { type: block.type }
                 if (block.content) stored.content = block.content
                 if (block.type === 'tool_call' && block.toolCall) {
+                  const state =
+                    block.toolCall.result?.success !== undefined
+                      ? block.toolCall.result.success
+                        ? 'success'
+                        : 'error'
+                      : block.toolCall.status
+                  const isSubagentTool = !!block.calledBy
+                  const isNonTerminal =
+                    state === 'cancelled' || state === 'pending' || state === 'executing'
                   stored.toolCall = {
                     id: block.toolCall.id,
                     name: block.toolCall.name,
-                    state:
-                      block.toolCall.result?.success !== undefined
-                        ? block.toolCall.result.success
-                          ? 'success'
-                          : 'error'
-                        : block.toolCall.status,
-                    result: block.toolCall.result,
+                    state,
+                    ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
+                    ...(isSubagentTool && isNonTerminal
+                      ? {}
+                      : block.toolCall.params
+                        ? { params: block.toolCall.params }
+                        : {}),
                     ...(block.calledBy ? { calledBy: block.calledBy } : {}),
                   }
                 }
@@ -426,7 +434,6 @@ export async function POST(req: NextRequest) {
       goRoute: '/api/copilot',
       autoExecuteTools: true,
       interactive: true,
-      promptForToolApproval: false,
     })
 
     const responseData = {

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

@@ -0,0 +1,59 @@
+/**
+ * @vitest-environment node
+ */
+
+import { NextRequest } from 'next/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { getStreamMeta, readStreamEvents, authenticateCopilotRequestSessionOnly } = vi.hoisted(
+  () => ({
+    getStreamMeta: vi.fn(),
+    readStreamEvents: vi.fn(),
+    authenticateCopilotRequestSessionOnly: vi.fn(),
+  })
+)
+
+vi.mock('@/lib/copilot/orchestrator/stream/buffer', () => ({
+  getStreamMeta,
+  readStreamEvents,
+}))
+
+vi.mock('@/lib/copilot/request-helpers', () => ({
+  authenticateCopilotRequestSessionOnly,
+}))
+
+import { GET } from '@/app/api/copilot/chat/stream/route'
+
+describe('copilot chat stream replay route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    authenticateCopilotRequestSessionOnly.mockResolvedValue({
+      userId: 'user-1',
+      isAuthenticated: true,
+    })
+    readStreamEvents.mockResolvedValue([])
+  })
+
+  it('stops replay polling when stream meta becomes cancelled', async () => {
+    getStreamMeta
+      .mockResolvedValueOnce({
+        status: 'active',
+        userId: 'user-1',
+      })
+      .mockResolvedValueOnce({
+        status: 'cancelled',
+        userId: 'user-1',
+      })
+
+    const response = await GET(
+      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1')
+    )
+
+    const reader = response.body?.getReader()
+    expect(reader).toBeTruthy()
+
+    const first = await reader!.read()
+    expect(first.done).toBe(true)
+    expect(getStreamMeta).toHaveBeenCalledTimes(2)
+  })
+})

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

@@ -80,6 +80,33 @@ export async function GET(request: NextRequest) {
     async start(controller) {
       let lastEventId = Number.isFinite(fromEventId) ? fromEventId : 0
       let latestMeta = meta
+      let controllerClosed = false
+
+      const closeController = () => {
+        if (controllerClosed) return
+        controllerClosed = true
+        try {
+          controller.close()
+        } catch {
+          // Controller already closed by runtime/client - treat as normal.
+        }
+      }
+
+      const enqueueEvent = (payload: Record<string, any>) => {
+        if (controllerClosed) return false
+        try {
+          controller.enqueue(encodeEvent(payload))
+          return true
+        } catch {
+          controllerClosed = true
+          return false
+        }
+      }
+
+      const abortListener = () => {
+        controllerClosed = true
+      }
+      request.signal.addEventListener('abort', abortListener, { once: true })
 
       const flushEvents = async () => {
         const events = await readStreamEvents(streamId, lastEventId)
@@ -99,37 +126,50 @@ export async function GET(request: NextRequest) {
             executionId: latestMeta?.executionId,
             runId: latestMeta?.runId,
           }
-          controller.enqueue(encodeEvent(payload))
+          if (!enqueueEvent(payload)) {
+            break
+          }
         }
       }
 
       try {
         await flushEvents()
 
-        while (Date.now() - startTime < MAX_STREAM_MS) {
+        while (!controllerClosed && Date.now() - startTime < MAX_STREAM_MS) {
           const currentMeta = await getStreamMeta(streamId)
           if (!currentMeta) break
           latestMeta = currentMeta
 
           await flushEvents()
 
-          if (currentMeta.status === 'complete' || currentMeta.status === 'error') {
+          if (controllerClosed) {
+            break
+          }
+          if (
+            currentMeta.status === 'complete' ||
+            currentMeta.status === 'error' ||
+            currentMeta.status === 'cancelled'
+          ) {
             break
           }
 
           if (request.signal.aborted) {
+            controllerClosed = true
             break
           }
 
           await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
         }
       } catch (error) {
-        logger.warn('Stream replay failed', {
-          streamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
+        if (!controllerClosed && !request.signal.aborted) {
+          logger.warn('Stream replay failed', {
+            streamId,
+            error: error instanceof Error ? error.message : String(error),
+          })
+        }
       } finally {
-        controller.close()
+        request.signal.removeEventListener('abort', abortListener)
+        closeController()
       }
     },
   })