Add finalization on error

Author: Sg312

apps/sim/lib/copilot/chat/post.ts

@@ -457,12 +457,19 @@ function buildOnComplete(params: {
         return
       }
 
+      // On a non-success terminal (e.g. a transient provider error like
+      // "overloaded"), persist whatever streamed before the failure — same as
+      // the cancelled path — instead of dropping the partial assistant output.
+      const assistantMessage = buildPersistedAssistantMessage(result, requestId)
+      const hasPartial =
+        !!assistantMessage.content?.trim() || (assistantMessage.contentBlocks?.length ?? 0) > 0
       await finalizeAssistantTurn({
         chatId,
         userMessageId,
-        ...(result.success
-          ? { assistantMessage: buildPersistedAssistantMessage(result, requestId) }
-          : {}),
+        ...(result.success || hasPartial ? { assistantMessage } : {}),
+        // Match the cancelled path so the partial still persists if onError
+        // raced ahead and already cleared the stream marker.
+        ...(result.success ? {} : { streamMarkerPolicy: 'active-or-cleared' as const }),
       })
 
       if (notifyWorkspaceStatus && workspaceId) {

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

@@ -115,23 +115,43 @@ async function handleError(
     result.errors?.[0] ||
     'An unexpected error occurred while processing the response.'
 
+  // Persist whatever was generated before the failure, exactly like an abort —
+  // a transient provider error (e.g. overloaded) shouldn't discard the partial
+  // assistant output the user already saw streaming.
+  const partialContent = result.content || undefined
+  const partialContentLen = result.content?.length ?? 0
+  const toolCallCount = result.toolCalls?.length ?? 0
+
   if (publisher.clientDisconnected) {
     logger.info(`[${requestId}] Stream failed after client disconnect`, { error: errorMessage })
   }
-  logger.error(`[${requestId}] Orchestration returned failure`, { error: errorMessage })
+  logger.error(`[${requestId}] Orchestration returned failure`, {
+    error: errorMessage,
+    partialContentLen,
+    toolCallCount,
+  })
 
+  // Surface the real error (Go already classifies provider errors like
+  // "overloaded" into a friendly displayMessage). Don't clobber it with a
+  // generic string.
   await publisher.publish({
     type: MothershipStreamV1EventType.error,
     payload: {
       message: errorMessage,
       error: errorMessage,
-      data: { displayMessage: 'An unexpected error occurred while processing the response.' },
+      displayMessage: errorMessage,
+      data: { displayMessage: errorMessage },
     },
   })
   if (!publisher.sawComplete) {
     await publisher.publish({
       type: MothershipStreamV1EventType.complete,
-      payload: { status: MothershipStreamV1CompletionStatus.error },
+      payload: {
+        status: MothershipStreamV1CompletionStatus.error,
+        ...(partialContent ? { partialContent } : {}),
+        ...(partialContentLen ? { partialContentLen } : {}),
+        ...(toolCallCount ? { toolCallCount } : {}),
+      },
     })
   }
   await publisher.flush()