fix(mothership): keep any queued send the server may already hold from being edited

#8717 blocked edits only for a first message the unmount queued itself. A
send handed to another surface, or re-queued after its dispatch got no
answer, also carries an earlier attempt's id and was still editable; an edit
dropped that id and could send a second message. The queue store now marks
every message resuming an earlier attempt as admissionUnknown unless the
writer knows the server refused it or never got it (a busy refusal, a
superseded 409, a Stop that never settled), which also makes a held message
editable again once the server refuses it.

Author: waleedlatif1

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

@@ -2151,11 +2151,6 @@ describe('useChat remount send recovery', () => {
     expect(allQueuedMessages()).toHaveLength(0)
   })
 
-  /**
-   * After a Stop of the first message, only the follow-up was the user's
-   * intent: the Stop's POST is left to the server, nothing withdraws it, and the
-   * next mount sends just the follow-up, once.
-   */
   /**
    * A first message held at the queue head after a remount may already be a
    * turn on the server. Editing it would send different text under a new id,
@@ -2204,6 +2199,159 @@ describe('useChat remount send recovery', () => {
     })
   })
 
+  /** A chat with a turn running, so anything sent to it waits in its queue. */
+  function renderBusyChat(id: string) {
+    const history: MothershipChatHistory = {
+      id,
+      mode: 'agent',
+      title: 'Busy',
+      messages: [],
+      activeStreamId: 'turn-still-running',
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (String(input).includes('/api/mothership/chat/stream')) {
+        if (String(input).includes('batch=true')) {
+          return Response.json({ success: true, events: [], status: 'streaming' })
+        }
+        return new Response(new ReadableStream<Uint8Array>(), {
+          headers: { 'Content-Type': 'text/event-stream' },
+        })
+      }
+      return fetchStub(input, init)
+    })
+    return { history, ...renderUseChatInChat(id, history) }
+  }
+
+  /**
+   * A send another surface withdrew arrives here under its original id, through
+   * the send event or the stored handoff. Queued behind a running turn, it may
+   * already be a turn on the server, so it can't be edited either.
+   */
+  it('does not let a withdrawn send handed to a busy chat be edited', async () => {
+    const { history, getResult } = renderBusyChat('chat-busy-on-handoff')
+    await waitFor(() => getResult().isSending)
+    await act(async () => {
+      await getResult().sendMessage('handed over from another surface', undefined, undefined, {
+        resumeUserMessageId: 'withdrawn-attempt',
+      })
+    })
+    const queued = useMothershipQueueStore.getState().queues[history.id]?.[0]
+    expect(queued?.resumeUserMessageId).toBe('withdrawn-attempt')
+
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage(queued?.id ?? '')
+    })
+
+    expect(edited).toBeUndefined()
+    expect(getResult().editingQueuedId).toBeNull()
+  })
+
+  /** A follow-up whose dispatch got no answer may have reached the server too. */
+  it('does not let a queued follow-up be edited after its send got no answer', async () => {
+    const history: MothershipChatHistory = {
+      id: 'chat-follow-up-unanswered',
+      mode: 'agent',
+      title: 'Unanswered',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (String(input) === '/api/mothership/chat' && init?.method === 'POST') {
+        state.postBodies.push(JSON.parse(String(init.body)))
+        throw new TypeError('Failed to fetch')
+      }
+      return fetchStub(input, init)
+    })
+    useMothershipQueueStore
+      .getState()
+      .enqueue(history.id, { id: 'follow-up', content: 'and the second invoice' })
+    const { getResult } = renderUseChatInChat(history.id, history)
+    await waitFor(
+      () =>
+        useMothershipQueueStore.getState().queues[history.id]?.[0]?.resumeUserMessageId !==
+        undefined
+    )
+
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage('follow-up')
+    })
+
+    expect(edited).toBeUndefined()
+    expect(useMothershipQueueStore.getState().queues[history.id]?.[0]).toMatchObject({
+      content: 'and the second invoice',
+      resumeUserMessageId: state.postBodies[0].userMessageId,
+    })
+  })
+
+  /**
+   * A held message the server then refuses as busy is known not to be a turn
+   * there: the server answers a retry of an admitted id as a duplicate, never
+   * as busy. The user can edit it again.
+   */
+  it('lets a held message be edited again once the server refuses it as busy', async () => {
+    const history: MothershipChatHistory = {
+      id: 'chat-held-then-refused',
+      mode: 'agent',
+      title: 'Refused',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+    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)))
+        return Response.json(
+          {
+            error: 'A response is already in progress for this chat.',
+            activeStreamId: 'turn-from-another-tab',
+          },
+          { status: 409 }
+        )
+      }
+      if (url.includes('/api/mothership/chat/stream')) {
+        if (url.includes('batch=true')) {
+          return Response.json({ success: true, events: [], status: 'streaming' })
+        }
+        return new Response(new ReadableStream<Uint8Array>(), {
+          headers: { 'Content-Type': 'text/event-stream' },
+        })
+      }
+      return fetchStub(input, init)
+    })
+    useMothershipQueueStore.getState().enqueue(history.id, {
+      id: 'held-first',
+      content: 'inspect the workspace',
+      resumeUserMessageId: 'first-attempt',
+      admissionUnknown: true,
+    })
+    const { getResult } = renderUseChatInChat(history.id, history)
+    await waitFor(() => state.postBodies.length === 1)
+    await waitFor(
+      () => useMothershipQueueStore.getState().queues[history.id]?.[0]?.id === 'held-first'
+    )
+
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage('held-first')
+    })
+
+    expect(edited?.content).toBe('inspect the workspace')
+    expect(getResult().editingQueuedId).toBe('held-first')
+  })
+
+  /**
+   * After a Stop of the first message, only the follow-up was the user's
+   * intent: the Stop's POST is left to the server, nothing withdraws it, and the
+   * next mount sends just the follow-up, once.
+   */
   it('sends only the follow-up after a failed Stop when the new-chat surface remounts', async () => {
     stubFirstPostPendingThenAdmitted()
     const first = renderHomeLikeSurface()

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

@@ -234,6 +234,11 @@ interface WithdrawnSendResult {
   busy?: boolean
   /** Not sent at all (its Stop handoff failed); kept queued for the user to send. */
   held?: boolean
+  /**
+   * The server is known not to have it: it was never sent, or the server
+   * refused it outright. Its queue entry can be edited.
+   */
+  notAdmitted?: boolean
 }
 
 /**
@@ -3887,7 +3892,7 @@ export function useChat(
             setError(getErrorMessage(err, 'Failed to stop the previous response'))
             /* Nothing was sent. Hand the message back so it stays in its chat's queue
                even if the user has switched chats since the Stop began. */
-            return { userMessageId, held: true }
+            return { userMessageId, held: true, notAdmitted: true }
           }
         }
 
@@ -4004,7 +4009,7 @@ export function useChat(
               }
               if (viewOnSend)
                 setError('Previous response is still shutting down; queued message was restored.')
-              return { userMessageId, held: true }
+              return { userMessageId, held: true, notAdmitted: true }
             }
             /** Withdraws this refused send so the queue retries it, under the same id, later. */
             const releaseRefusedSend = () => {
@@ -4040,7 +4045,7 @@ export function useChat(
                   exact: true,
                   refetchType: 'none',
                 })
-              return { userMessageId, busy: true }
+              return { userMessageId, busy: true, notAdmitted: true }
             }
             /* "Already sent" with no stream for it means the earlier attempt is still
                in flight on the server (or died before starting a turn), not that a turn
@@ -4414,6 +4419,7 @@ export function useChat(
           : {}),
         ...(result.held ? { retryRequired: true } : {}),
         ...(result.busy ? busyRetry(1) : {}),
+        ...(result.notAdmitted ? { admissionUnknown: false } : {}),
         ...((result.unreachable || result.busy) && activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
           ? { heldSurface: heldSendSurface }
           : {}),
@@ -5043,6 +5049,8 @@ export function useChat(
             ? { heldSurface: heldSendSurface }
             : {}),
           ...(withdrawnUserMessageId ? { resumeUserMessageId: withdrawnUserMessageId } : {}),
+          /** This attempt's outcome decides; an earlier refusal says nothing about it. */
+          ...(withdrawn ? { admissionUnknown: !withdrawn.notAdmitted } : {}),
         })
       }
 

apps/sim/app/workspace/[workspaceId]/home/types.ts

@@ -35,9 +35,10 @@ export interface QueuedMessage {
   assistantSearch?: WorkspaceSearchFilters
   assistantSearchLevel?: AssistantSearchLevel
   /**
-   * A first message withdrawn before the server answered. The server may
-   * already hold it as sent, so it goes out exactly as written, under its
-   * original id, and cannot be edited into a different message.
+   * An earlier attempt at this message got no answer, so the server may
+   * already hold it as sent. It goes out exactly as written, under that
+   * attempt's id, and cannot be edited into a different message. False once
+   * the server is known not to have it (it refused it, or it was never sent).
    */
   admissionUnknown?: boolean
 }

apps/sim/stores/mothership-queue/store.test.ts

@@ -30,6 +30,24 @@ describe('useMothershipQueueStore', () => {
   })
 
   describe('replaceAt', () => {
+    it('treats any message resuming an earlier attempt as possibly sent, unless told otherwise', () => {
+      useMothershipQueueStore
+        .getState()
+        .enqueue('chat-A', { id: 'resumed', content: 'original', resumeUserMessageId: 'attempt-1' })
+      useMothershipQueueStore.getState().insertAt('chat-A', 0, {
+        id: 'refused',
+        content: 'original',
+        resumeUserMessageId: 'attempt-2',
+        admissionUnknown: false,
+      })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'resumed', { content: 'edited' })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'refused', { content: 'edited' })
+
+      const [refused, resumed] = useMothershipQueueStore.getState().queues['chat-A'] ?? []
+      expect(resumed).toMatchObject({ content: 'original', resumeUserMessageId: 'attempt-1' })
+      expect(refused?.content).toBe('edited')
+    })
+
     it('leaves a first message the server may already hold unchanged, with its id', () => {
       useMothershipQueueStore.getState().enqueue('chat-A', {
         id: 'm1',
@@ -50,6 +68,8 @@ describe('useMothershipQueueStore', () => {
         content: 'original',
         retryRequired: true,
         resumeUserMessageId: 'prior-request',
+        /** Its Stop never settled, so it was never sent: the server cannot hold it. */
+        admissionUnknown: false,
         queuedSendHandoff: {
           id: 'm1',
           chatId: 'chat-A',

apps/sim/stores/mothership-queue/store.ts

@@ -50,6 +50,19 @@ const initialState = {
   cleared: {} as Record<string, number>,
 }
 
+/**
+ * A message resuming an earlier attempt (`resumeUserMessageId`) may already be
+ * a turn on the server, unless the writer knows it is not
+ * (`admissionUnknown: false`). Every queue write goes through this, so no path
+ * can queue such a message as editable by leaving the flag out.
+ */
+function withAdmissionGuard(message: QueuedMothershipMessage): QueuedMothershipMessage {
+  if (message.resumeUserMessageId === undefined || message.admissionUnknown !== undefined) {
+    return message
+  }
+  return { ...message, admissionUnknown: true }
+}
+
 const omitKey = <V>(record: Record<string, V>, key: string): Record<string, V> => {
   if (!(key in record)) return record
   const { [key]: _removed, ...rest } = record
@@ -75,7 +88,7 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             return {
               queues: setQueueForChat(state.queues, chatKey, [
                 ...(state.queues[chatKey] ?? []),
-                message,
+                withAdmissionGuard(message),
               ]),
             }
           }),
@@ -87,7 +100,7 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             const current = state.queues[chatKey] ?? []
             if (current.some((m) => m.id === message.id)) return state
             const next = [...current]
-            next.splice(Math.max(0, Math.min(index, next.length)), 0, message)
+            next.splice(Math.max(0, Math.min(index, next.length)), 0, withAdmissionGuard(message))
             return { queues: setQueueForChat(state.queues, chatKey, next) }
           }),