fix(mothership): retry a deduplicated send whose stream lookup failed

A lookup that failed with a network error or 5xx was read as proof that the
earlier attempt's stream existed, so a send that never started was
reattached and finalized instead of re-sent. Only a lookup this send aborted
skips the retry now; the server deduplicates the retry by id.

Author: waleedlatif1

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

@@ -3073,6 +3073,43 @@ describe('useChat remount send recovery', () => {
       ).toEqual(['Follow-up after the restore'])
     })
 
+    /** A stream lookup that fails for another reason does not prove a turn ran either. */
+    it('retries a deduplicated send whose stream lookup failed', async () => {
+      const history = idleHistory('chat-deduped-lookup-failed')
+      mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+      let posts = 0
+      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)))
+          posts++
+          if (posts === 1) {
+            return Response.json(
+              {
+                error: 'This message was already sent.',
+                activeStreamId: state.postBodies[0].userMessageId,
+              },
+              { status: 409 }
+            )
+          }
+          return emptySseResponse()
+        }
+        if (url.includes('/api/mothership/chat/stream') && posts === 1) {
+          return Response.json({ error: 'Internal error' }, { status: 500 })
+        }
+        return fetchStub(input, init)
+      })
+      const { getResult } = renderUseChatInChat(history.id, history)
+
+      await act(async () => {
+        await getResult().sendMessage('Told it was already sent, lookup failed')
+      })
+      await waitFor(() => state.postBodies.length === 2, 5_000)
+
+      expect(state.postBodies[1].message).toBe('Told it was already sent, lookup failed')
+      expect(state.postBodies[1].userMessageId).toBe(state.postBodies[0].userMessageId)
+    })
+
     /**
      * On the new-chat surface the "already sent" answer also names the chat the
      * earlier attempt opened. With no stream yet, the retry must still go out,

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

@@ -4024,14 +4024,17 @@ export function useChat(
                ran: reattaching would read the missing stream as finished and drop the
                message. Retry it later like a busy refusal; the server's claim settles.
                This is checked before adopting the chat the answer names, so a retried
-               message stays under the key it was sent from. */
+               message stays under the key it was sent from. A lookup that fails for
+               another reason proves nothing either way, so it is retried too: the server
+               deduplicates the retry by id. Only a lookup this send aborted (Stop, or the
+               user moving on) is not retried. */
             const dedupedStreamExists = await fetchStreamBatch(
               conflictStreamId,
               '0',
               abortController.signal
             ).then(
               () => true,
-              (error: unknown) => !isStreamGoneError(error)
+              (error: unknown) => !isStreamGoneError(error) && abortController.signal.aborted
             )
             if (!dedupedStreamExists) {
               releaseRefusedSend()