address bugbot comment

Author: icecrasher321

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

@@ -51,18 +51,18 @@ export const POST = withRouteHandler((req: NextRequest) =>
 
       const hasContent = content.trim().length > 0
       const hasBlocks = Array.isArray(contentBlocks) && contentBlocks.length > 0
-      const synthesizedStoppedBlocks = hasBlocks
+      const assistantBlocks = hasBlocks
         ? contentBlocks
         : hasContent
-          ? [{ type: 'text', channel: 'assistant', content }, { type: 'stopped' }]
-          : [{ type: 'stopped' }]
+          ? [{ type: 'text', channel: 'assistant', content }]
+          : []
       const assistantMessage: PersistedMessage = withStoppedContentBlock(
         normalizeMessage({
           id: generateId(),
           role: 'assistant',
           content,
           timestamp: new Date().toISOString(),
-          contentBlocks: synthesizedStoppedBlocks,
+          contentBlocks: assistantBlocks,
           ...(requestId ? { requestId } : {}),
         })
       )

apps/sim/lib/copilot/request/lifecycle/run.test.ts

@@ -165,4 +165,61 @@ describe('runCopilotLifecycle', () => {
       })
     )
   })
+
+  it('returns the cancelled result when cancelled completion persistence fails', async () => {
+    const abortController = new AbortController()
+    abortController.abort('stop')
+    const onComplete = vi.fn().mockRejectedValue(new Error('db unavailable'))
+    const onError = vi.fn()
+    const executionContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: '',
+      workspaceId: 'ws-1',
+      chatId: 'chat-1',
+      decryptedEnvVars: {},
+    }
+
+    mockRunStreamLoop.mockImplementationOnce(
+      async (
+        _fetchUrl: string,
+        _fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        context.accumulatedContent = 'partial answer'
+        throw new Error('publisher closed after stop')
+      }
+    )
+
+    const result = await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-1' },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        chatId: 'chat-1',
+        executionId: 'exec-1',
+        runId: 'run-1',
+        abortSignal: abortController.signal,
+        executionContext,
+        onComplete,
+        onError,
+      }
+    )
+
+    expect(onError).not.toHaveBeenCalled()
+    expect(onComplete).toHaveBeenCalledWith(
+      expect.objectContaining({
+        success: false,
+        cancelled: true,
+        content: 'partial answer',
+      })
+    )
+    expect(result).toEqual(
+      expect.objectContaining({
+        success: false,
+        cancelled: true,
+        content: 'partial answer',
+        error: 'publisher closed after stop',
+      })
+    )
+  })
 })

apps/sim/lib/copilot/request/lifecycle/run.ts

@@ -167,24 +167,7 @@ export async function runCopilotLifecycle(
     // Return `cancelled: true` so upstream classification stays
     // consistent with the success-path cancel result.
     const wasCancelled = lifecycleOptions.abortSignal?.aborted ?? false
-    if (!wasCancelled) {
-      await lifecycleOptions.onError?.(err)
-    } else if (!onCompleteStarted && lifecycleOptions.onComplete) {
-      await lifecycleOptions.onComplete({
-        success: false,
-        cancelled: true,
-        content: context.accumulatedContent,
-        contentBlocks: context.contentBlocks,
-        toolCalls: buildToolCallSummaries(context),
-        chatId: context.chatId,
-        requestId: context.requestId,
-        error: err.message,
-        errors: context.errors.length ? context.errors : undefined,
-        usage: context.usage,
-        cost: context.cost,
-      })
-    }
-    return {
+    const result: OrchestratorResult = {
       success: false,
       cancelled: wasCancelled,
       content: wasCancelled ? context.accumulatedContent : '',
@@ -197,6 +180,19 @@ export async function runCopilotLifecycle(
       usage: context.usage,
       cost: context.cost,
     }
+
+    if (!wasCancelled) {
+      await lifecycleOptions.onError?.(err)
+    } else if (!onCompleteStarted && lifecycleOptions.onComplete) {
+      try {
+        await lifecycleOptions.onComplete(result)
+      } catch (completeError) {
+        logger.error('Cancelled copilot completion callback failed', {
+          error: toError(completeError).message,
+        })
+      }
+    }
+    return result
   }
 }