fix(mothership): don't hold a send whose network returned while it was failing

An `online` event can fire while the failing POST is still pending, so the
release ran before the message was held and the message then waited for a
release that had already happened. A send now notes whether the browser came
back online while it was in flight, and if so goes back to the queue unheld,
for the drain to send under its usual rules.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.dom.test.tsx

@@ -2156,6 +2156,47 @@ describe('useChat remount send recovery', () => {
       )
     })
 
+    /**
+     * The browser can come back online while the failing POST is still pending,
+     * so the release fires before the message is held. It must not then wait
+     * for a release that already happened.
+     */
+    it('sends a message whose POST failed after the network had already returned', async () => {
+      const history = idleHistory('chat-online-mid-send')
+      mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+      let failFirstPost: (() => void) | undefined
+      vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = String(input)
+        if (url === '/api/mothership/chat' && init?.method === 'POST') {
+          state.postBodies.push(JSON.parse(String(init.body)))
+          if (state.postBodies.length === 1) {
+            return new Promise<Response>((_, reject) => {
+              failFirstPost = () => reject(new TypeError('Failed to fetch'))
+            })
+          }
+          return emptySseResponse()
+        }
+        if (url.includes('/api/mothership/chat/stream')) {
+          return Response.json({ error: 'Stream not found' }, { status: 404 })
+        }
+        return fetchStub(input, init)
+      })
+      const { getResult } = renderUseChatInChat(history.id, history)
+      await act(async () => {
+        void getResult().sendMessage('Sent as the network came back')
+      })
+      await waitFor(() => failFirstPost !== undefined)
+
+      await act(async () => {
+        window.dispatchEvent(new Event('online'))
+        failFirstPost?.()
+      })
+      await waitFor(() => state.postBodies.length === 2)
+
+      expect(state.postBodies[1].message).toBe('Sent as the network came back')
+      expect(state.postBodies[1].userMessageId).toBe(state.postBodies[0].userMessageId)
+    })
+
     /** The `online` event can fire while no surface for the chat is mounted. */
     it('sends a held message when its chat mounts after the network came back', async () => {
       const history = idleHistory('chat-held-while-away')

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -209,11 +209,14 @@ interface FinalizeOptions {
  * A send handed back to the caller instead of rendered. `userMessageId` is what
  * a retry reuses so the server deduplicates the two attempts. An `unreachable`
  * send is held in the queue until the browser is back online or the user sends
- * it: dispatching it again at once would fail the same way.
+ * it: dispatching it again at once would fail the same way. When the browser
+ * came back online while that send was failing (`networkReturned`), the release
+ * it would have waited for has already fired, so it is not held.
  */
 interface WithdrawnSendResult {
   userMessageId: string
   unreachable?: boolean
+  networkReturned?: boolean
 }
 
 /**
@@ -729,6 +732,8 @@ export function useChat(
   const pendingStopModeRef = useRef<StopGenerationMode | null>(null)
   const workflowIdRef = useRef(options?.workflowId)
   workflowIdRef.current = options?.workflowId
+  /** Counts `online` events, so a send can tell the network returned while it was failing. */
+  const onlineEventsRef = useRef(0)
   /** Identifies this chatless surface across mounts, for the sends it holds. */
   const heldSendSurface = `${scopeKey}:${options?.workflowId ?? 'home'}`
   const onToolResultRef = useRef(options?.onToolResult)
@@ -3422,6 +3427,7 @@ export function useChat(
 
       let consumedByTranscript = false
       let sendReachedServer = false
+      const onlineEventsAtSend = onlineEventsRef.current
 
       setError(null)
       setTransportStreaming()
@@ -4019,7 +4025,11 @@ export function useChat(
               ? 'Message not sent: Sim could not be reached. It will send when you are back online.'
               : getErrorMessage(err, 'Failed to send message')
           )
-          return { userMessageId, unreachable: true }
+          return {
+            userMessageId,
+            unreachable: true,
+            ...(onlineEventsRef.current !== onlineEventsAtSend ? { networkReturned: true } : {}),
+          }
         }
 
         const activeStreamId = streamIdRef.current
@@ -4210,14 +4220,11 @@ export function useChat(
           options?.assistantSearch,
           options?.assistantSearchLevel
         ),
-        ...(result.unreachable
-          ? {
-              retryRequired: true,
-              heldUntilOnline: true,
-              ...(activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
-                ? { heldSurface: heldSendSurface }
-                : {}),
-            }
+        ...(result.unreachable && !result.networkReturned
+          ? { retryRequired: true, heldUntilOnline: true }
+          : {}),
+        ...(result.unreachable && activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
+          ? { heldSurface: heldSendSurface }
           : {}),
       })
     },
@@ -4825,14 +4832,12 @@ export function useChat(
         useMothershipQueueStore.getState().insertAt(dispatchChatKey, originalIndex, {
           ...dispatched,
           ...(retainedHandoff ? { queuedSendHandoff: retainedHandoff } : {}),
-          retryRequired: !retriesOnItsOwn,
-          ...(withdrawn?.unreachable
-            ? {
-                heldUntilOnline: true,
-                ...(dispatchChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
-                  ? { heldSurface: heldSendSurface }
-                  : {}),
-              }
+          retryRequired: withdrawn?.unreachable ? !withdrawn.networkReturned : !retriesOnItsOwn,
+          ...(withdrawn?.unreachable && !withdrawn.networkReturned
+            ? { heldUntilOnline: true }
+            : {}),
+          ...(withdrawn?.unreachable && dispatchChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
+            ? { heldSurface: heldSendSurface }
             : {}),
           ...(withdrawnUserMessageId ? { resumeUserMessageId: withdrawnUserMessageId } : {}),
         })
@@ -5053,12 +5058,16 @@ export function useChat(
   useEffect(() => {
     if (typeof window === 'undefined') return
     const releaseHeldSends = () => useMothershipQueueStore.getState().releaseHeldUntilOnline()
+    const handleOnline = () => {
+      onlineEventsRef.current++
+      releaseHeldSends()
+    }
     if (chatKey.startsWith(PENDING_CHAT_KEY_PREFIX)) {
       useMothershipQueueStore.getState().adoptHeldSends(chatKey, heldSendSurface)
     }
     if (navigator.onLine) releaseHeldSends()
-    window.addEventListener('online', releaseHeldSends)
-    return () => window.removeEventListener('online', releaseHeldSends)
+    window.addEventListener('online', handleOnline)
+    return () => window.removeEventListener('online', handleOnline)
   }, [chatKey, heldSendSurface])
 
   /** A recovered send already in history belongs to its accepted turn, even after Stop. */