fix(copilot): retain resource removal intent

Author: j15z

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

@@ -1815,7 +1815,7 @@ export function useChat(
         (r) => r.type === resourceUpdate.type && r.id === resourceUpdate.id
       )
       const resource = mergeChatResource(existing, resourceUpdate)
-      if (existing && resource === existing) {
+      if (existing && resource === existing && resourceUpdate.clearViewId !== true) {
         return false
       }
 
@@ -1861,8 +1861,6 @@ export function useChat(
       scheduleDelete(persistChatId, () =>
         requestJson(removeMothershipChatResourceContract, {
           body: { chatId: persistChatId, resourceType, resourceId },
-        }).catch((err) => {
-          logger.warn('Failed to persist resource removal', err)
         })
       )
     },

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx

@@ -726,8 +726,8 @@ export function Table({
       viewPin.viewId,
       pendingCreatedViewIdRef.current
     )
-    if (!transition.nextViewId) return
     pendingCreatedViewIdRef.current = transition.pendingCreatedViewId
+    if (!transition.nextViewId) return
     preservedViewStateRef.current = null
     setTableParams({ view: transition.nextViewId })
   }, [embedded, viewPin, views, activeViewId, tableId, consumeViewPin, setTableParams])

apps/sim/lib/copilot/resources/client-persistence-queue.test.ts

@@ -155,4 +155,26 @@ describe('ResourcePersistenceQueue', () => {
     await vi.waitFor(() => expect(persist).toHaveBeenCalledTimes(2))
     expect(persist.mock.calls[1]).toEqual(['chat-1', { ...TABLE_RESOURCE, viewId: 'view-b' }])
   })
+
+  it('retries a failed deletion on the next flush', async () => {
+    const first = deferred<unknown>()
+    const persist = vi.fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
+    const remove = vi
+      .fn<() => Promise<unknown>>()
+      .mockReturnValueOnce(first.promise)
+      .mockResolvedValueOnce({ success: true })
+    const queue = new ResourcePersistenceQueue({ persist, onError })
+
+    const removal = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id)
+    removal.scheduleDelete('chat-1', remove)
+    first.reject(new Error('offline'))
+    await Promise.allSettled(Array.from(queue.inFlight.values()))
+
+    expect(queue.pendingKeys.has(`${TABLE_RESOURCE.type}:${TABLE_RESOURCE.id}`)).toBe(true)
+    expect(onError).toHaveBeenCalledOnce()
+    await queue.flush('chat-1')
+
+    expect(remove).toHaveBeenCalledTimes(2)
+    expect(queue.pendingKeys.size).toBe(0)
+  })
 })

apps/sim/lib/copilot/resources/client-persistence-queue.ts

@@ -25,6 +25,7 @@ export class ResourcePersistenceQueue {
 
   private readonly desiredUpdates = new Map<string, MothershipResourceUpdate>()
   private readonly failedKeys = new Set<string>()
+  private readonly pendingRemovals = new Map<string, () => Promise<unknown>>()
   private readonly persistedKeys = new Set<string>()
   private readonly removalTokens = new Map<string, symbol>()
   private readonly writeTokens = new Map<string, symbol>()
@@ -45,6 +46,7 @@ export class ResourcePersistenceQueue {
     const trackedLocally =
       this.desiredUpdates.has(key) || this.pendingKeys.has(key) || this.inFlight.has(key)
     if (base && !trackedLocally) this.persistedKeys.add(key)
+    this.pendingRemovals.delete(key)
     this.removalTokens.delete(key)
     const previous = this.desiredUpdates.get(key) ?? base
     this.desiredUpdates.set(key, mergePendingChatResourceUpdate(previous, update))
@@ -73,12 +75,14 @@ export class ResourcePersistenceQueue {
     const inFlight = this.inFlight.get(key)
     const wasPersisted = this.persistedKeys.delete(key)
     const removalToken = Symbol(key)
+    this.pendingRemovals.delete(key)
     this.removalTokens.set(key, removalToken)
     this.desiredUpdates.delete(key)
     this.failedKeys.delete(key)
     return {
       inFlight,
       scheduleDelete: (chatId, remove) => {
+        this.pendingRemovals.set(key, remove)
         const startRemoval = () => this.startRemoval(key, chatId, removalToken, remove)
         if (inFlight) {
           void inFlight.then(startRemoval, startRemoval)
@@ -103,14 +107,22 @@ export class ResourcePersistenceQueue {
     this.inFlight.clear()
     this.desiredUpdates.clear()
     this.failedKeys.clear()
+    this.pendingRemovals.clear()
     this.persistedKeys.clear()
     this.removalTokens.clear()
     this.writeTokens.clear()
   }
 
   private startPending(chatId: string): void {
     for (const key of this.pendingKeys) {
-      if (!this.failedKeys.has(key) && !this.inFlight.has(key)) this.start(key, chatId)
+      if (this.failedKeys.has(key) || this.inFlight.has(key)) continue
+      const pendingRemoval = this.pendingRemovals.get(key)
+      const removalToken = this.removalTokens.get(key)
+      if (pendingRemoval && removalToken) {
+        this.startRemoval(key, chatId, removalToken, pendingRemoval)
+        continue
+      }
+      this.start(key, chatId)
     }
   }
 
@@ -122,22 +134,33 @@ export class ResourcePersistenceQueue {
   ): void {
     if (this.removalTokens.get(key) !== removalToken) return
 
+    this.pendingKeys.delete(key)
+    let succeeded = false
     const writeToken = Symbol(key)
     const tracked = Promise.resolve()
-      .then(() => {
+      .then(async () => {
         if (this.removalTokens.get(key) !== removalToken) return
-        return remove()
+        await remove()
+        succeeded = true
+      })
+      .catch((error) => {
+        if (this.removalTokens.get(key) !== removalToken) return
+        this.pendingKeys.add(key)
+        this.failedKeys.add(key)
+        this.onError(error)
       })
-      .catch(this.onError)
       .finally(() => {
         if (this.writeTokens.get(key) !== writeToken) return
         this.writeTokens.delete(key)
         this.inFlight.delete(key)
-        if (this.removalTokens.get(key) === removalToken) {
+        if (succeeded && this.removalTokens.get(key) === removalToken) {
+          this.pendingRemovals.delete(key)
           this.removalTokens.delete(key)
           this.persistedKeys.delete(key)
         }
-        if (this.pendingKeys.has(key)) this.start(key, chatId)
+        if (this.removalTokens.get(key) !== removalToken && this.pendingKeys.has(key)) {
+          this.start(key, chatId)
+        }
       })
     this.writeTokens.set(key, writeToken)
     this.inFlight.set(key, tracked)