fix(chat): make a send's claim permanent only once its turn starts

The claim became permanent as soon as the chat resolved, but three exits still
return without starting a turn — a rejected branch, a missing chat, and a
pending-stream collision. The last one matters: the queued-send-handoff path
deliberately retries under the original `userMessageId` after a collision, and
against a permanent claim that retry deduplicated to a chat whose turn never
ran, reattaching to a stream that does not exist. A send that had merely
collided became unsendable for the claim's full hour.

The claim is now dropped immediately before the stream response is returned, so
`finally` releases it on every other exit. Recording the chat still happens as
early as possible — a concurrent duplicate needs somewhere to go — it just no
longer implies the turn happened.

Author: waleedlatif1

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

@@ -847,5 +847,52 @@ describe('handleUnifiedChatPost', () => {
       expect(createSSEStream).toHaveBeenCalled()
       expect(storeChatSendResult).not.toHaveBeenCalled()
     })
+
+    /**
+     * The queued-send-handoff path deliberately retries under the original
+     * `userMessageId` after a stream collision. If the collided attempt left a
+     * permanent claim, that retry would deduplicate against a chat whose turn
+     * never started and reattach to a stream that does not exist.
+     */
+    it('releases the claim when a stream collision stops the turn from starting', async () => {
+      acquirePendingChatStream.mockResolvedValue(false)
+      getPendingChatStreamId.mockResolvedValue('other-stream')
+
+      const response = await handleUnifiedChatPost(
+        new NextRequest('http://localhost/api/mothership/chat', {
+          method: 'POST',
+          body: JSON.stringify({
+            message: 'Hello',
+            workspaceId: 'ws-1',
+            userMessageId: 'msg-1',
+            createNewChat: true,
+          }),
+        })
+      )
+
+      expect(response.status).toBe(409)
+      expect(releaseChatSendClaim).toHaveBeenCalledWith(
+        'chat-send:user-message:msg-1:userId=user-1',
+        'database',
+        'claim-1'
+      )
+    })
+
+    it('keeps the claim once a turn is actually streaming', async () => {
+      const response = await handleUnifiedChatPost(
+        new NextRequest('http://localhost/api/mothership/chat', {
+          method: 'POST',
+          body: JSON.stringify({
+            message: 'Hello',
+            workspaceId: 'ws-1',
+            userMessageId: 'msg-1',
+            createNewChat: true,
+          }),
+        })
+      )
+
+      expect(response.status).toBe(200)
+      expect(releaseChatSendClaim).not.toHaveBeenCalled()
+    })
   })
 })

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

@@ -1142,9 +1142,10 @@ export async function handleUnifiedChatPost(req: NextRequest) {
       }
 
       /* Record the chat as soon as it is known — the earliest a retry can be
-         answered with somewhere to go. The claim becomes permanent here: the
-         user message lands moments later, so a retry must resolve to this chat
-         rather than open another. */
+         answered with somewhere to go. The claim is not permanent yet: several
+         exits below still return without starting a turn, and a retry of those
+         must be allowed to start one. Recording only fails open, so drop the
+         claim when it does. */
       if (sendClaim?.claimToken && actualChatId) {
         const recorded = await chatSendIdempotency
           .storeResult(
@@ -1160,7 +1161,7 @@ export async function handleUnifiedChatPost(req: NextRequest) {
             })
             return false
           })
-        if (recorded) sendClaim = undefined
+        if (!recorded) sendClaim = undefined
       }
 
       if (chatIsNew && actualChatId && body.resourceAttachments?.length) {
@@ -1456,6 +1457,11 @@ export async function handleUnifiedChatPost(req: NextRequest) {
       const rootTraceparent = `00-${rootCtx.traceId}-${rootCtx.spanId}-${
         (rootCtx.traceFlags & 0x1) === 0x1 ? '01' : '00'
       }`
+      /* A turn is running. Only now is the claim permanent, so the `finally`
+         below leaves it in place and a retry of this send resolves to this
+         chat instead of opening another. Every earlier exit returns without a
+         turn, and releases. */
+      sendClaim = undefined
       return new Response(stream, {
         headers: {
           ...SSE_RESPONSE_HEADERS,
@@ -1497,10 +1503,11 @@ export async function handleUnifiedChatPost(req: NextRequest) {
       { status: 500 }
     )
   } finally {
-    /* A claim still held here never recorded a chat — the send threw, or
-       returned early on a rejected branch or a missing chat. Release it so a
-       retry is treated as new rather than deduplicated against a chat that was
-       never opened. Must be `finally`: those early returns skip `catch`. */
+    /* A claim still held here never started a turn — the send threw, or
+       returned early on a rejected branch, a missing chat, or a chat that
+       already has a stream running. Release it so a retry may start one rather
+       than deduplicating against a turn that never happened. Must be
+       `finally`: those early returns skip `catch`. */
     if (sendClaim?.claimToken) {
       await chatSendIdempotency
         .release(sendClaim.normalizedKey, sendClaim.storageMethod, sendClaim.claimToken)