basalt-ui 1.11.0 → 1.13.0

package/src/agent/use-agent-thread-runs.test.tsx

@@ -17,7 +17,7 @@ import { act, renderHook, waitFor } from '@testing-library/react'
 import { useAgentThreadRuns } from './use-agent-thread-runs'
 import type { AgentThread, ThreadsStore } from './thread'
 import type { AgentTransport } from './transport'
-import type { AgentPart } from './parts'
+import type { AgentPart, AgentPartDraft } from './parts'
 import type { AgentOutcome, OutcomeResolver } from './outcome'
 
 // ── test-only ThreadsStore double — see use-agent-thread-runs.wedge.test.tsx for the rationale ──
@@ -100,6 +100,11 @@ function createTestThreadsStore(
       threads = []
       activeId = null
     },
+    // Always-hydrated, never-erroring — mirrors the localStorage-backed store's real values
+    // (see ThreadsStore.hydrated/.error doc comments); this double is a synchronous in-memory
+    // stand-in with no async load path to fail.
+    hydrated: true,
+    error: undefined,
   }
 }
 
@@ -130,7 +135,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(input) {
         await gates.get(input)?.promise
-        yield { type: 'text', text: `done:${input}` }
+        yield { id: 'p1', type: 'text', text: `done:${input}` }
       },
     }
 
@@ -173,7 +178,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
       async *stream(input) {
         calls.push(input)
         await gate.promise
-        yield { type: 'text', text: 'ok' }
+        yield { id: 'p1', type: 'text', text: 'ok' }
       },
     }
 
@@ -218,7 +223,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
         await gate.promise
-        yield { type: 'text', text: 'hi' }
+        yield { id: 'p1', type: 'text', text: 'hi' }
       },
     }
 
@@ -265,7 +270,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
       async *stream() {
         throw new Error('boom')
         // eslint-disable-next-line no-unreachable
-        yield { type: 'text', text: 'unreachable' }
+        yield { id: 'p1', type: 'text', text: 'unreachable' }
       },
     }
 
@@ -294,7 +299,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(input) {
         calls.push(input)
-        yield { type: 'text', text: 'x' }
+        yield { id: 'p1', type: 'text', text: 'x' }
       },
     }
 
@@ -316,7 +321,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(input) {
         calls.push(input)
-        yield { type: 'text', text: `done:${input}` }
+        yield { id: 'p1', type: 'text', text: `done:${input}` }
       },
     }
 
@@ -364,7 +369,7 @@ describe('useAgentThreadRuns — concurrency, no-op guard, finalize order, failu
 
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'hi' }
+        yield { id: 'p1', type: 'text', text: 'hi' }
       },
     }
 
@@ -403,11 +408,15 @@ describe('useAgentThreadRuns — stop()/stopAll() lifecycle', () => {
     const threadId = store.create()
 
     const gate = deferred<void>()
+    // Yields id-less drafts on purpose — the assertion below exists specifically to prove
+    // withPartIds stamps the missing id as `${threadId}#0`, so the cast documents that the type
+    // says AgentPart (identified) while this transport deliberately produces what the real
+    // contract is AgentPartDraft (a transport is always permitted to omit id).
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'partial' }
+        yield { type: 'text', text: 'partial' } as AgentPartDraft as AgentPart
         await gate.promise
-        yield { type: 'text', text: 'never arrives' }
+        yield { type: 'text', text: 'never arrives' } as AgentPartDraft as AgentPart
       },
     }
 
@@ -456,7 +465,7 @@ describe('useAgentThreadRuns — stop()/stopAll() lifecycle', () => {
 
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'hi' }
+        yield { id: 'p1', type: 'text', text: 'hi' }
       },
     }
 
@@ -498,7 +507,7 @@ describe('useAgentThreadRuns — stop()/stopAll() lifecycle', () => {
 
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'x' }
+        yield { id: 'p1', type: 'text', text: 'x' }
       },
     }
 
@@ -672,10 +681,10 @@ describe('useAgentThreadRuns — stop()/stopAll() lifecycle', () => {
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(input) {
         if (input === 'a') {
-          yield { type: 'text', text: 'partial-a' }
+          yield { id: 'p1', type: 'text', text: 'partial-a' }
           await gateA.promise
         } else {
-          yield { type: 'text', text: 'partial-b' }
+          yield { id: 'p1', type: 'text', text: 'partial-b' }
           await gateB.promise
         }
       },
@@ -748,17 +757,21 @@ describe('useAgentThreadRuns — F1 regression: id-less drafts within one run',
     const store = createTestThreadsStore()
     const threadId = store.create()
 
+    // Yields id-less drafts on purpose — the whole point of this regression is that TWO drafts
+    // (of different types, so a real bug wouldn't be "same id" but "no id at all") must not
+    // collide via `undefined === undefined`. The cast documents that the type says AgentPart
+    // (identified) while a transport is always permitted to omit id (AgentPartDraft).
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'Hi' }
+        yield { type: 'text', text: 'Hi' } as AgentPartDraft as AgentPart
         yield {
           type: 'tool',
           toolCallId: 'c1',
           toolName: 'search',
           state: 'input-available',
           input: { q: 'x' },
-        }
-        yield { type: 'text', text: 'Bye' }
+        } as AgentPartDraft as AgentPart
+        yield { type: 'text', text: 'Bye' } as AgentPartDraft as AgentPart
       },
     }
 
@@ -779,3 +792,329 @@ describe('useAgentThreadRuns — F1 regression: id-less drafts within one run',
     expect(assistantMessage?.parts.map((part) => part.type)).toEqual(['text', 'tool', 'text'])
   })
 })
+
+describe('useAgentThreadRuns — message-id minting under degraded crypto', () => {
+  test('start() mints distinct message ids via crypto.getRandomValues when randomUUID is unavailable', async () => {
+    const store = createTestThreadsStore()
+    const threadA = store.create()
+    const threadB = store.create()
+
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream(input) {
+        yield { id: 'p1', type: 'text', text: `done:${input}` }
+      },
+    }
+
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', {
+      value: { getRandomValues: originalCrypto.getRandomValues.bind(originalCrypto) },
+      configurable: true,
+    })
+    try {
+      const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+      act(() => {
+        result.current.start(threadA, 'input-a')
+        result.current.start(threadB, 'input-b')
+      })
+
+      await waitFor(() => {
+        expect(store.threads.find((t) => t.id === threadA)?.status).toBe('done')
+        expect(store.threads.find((t) => t.id === threadB)?.status).toBe('done')
+      })
+
+      const allMessageIds = store.threads.flatMap((t) => t.messages.map((m) => m.id))
+      expect(allMessageIds.length).toBeGreaterThan(0)
+      expect(new Set(allMessageIds).size).toBe(allMessageIds.length)
+    } finally {
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+  })
+
+  test('start() THROWS on a host with no usable crypto at all, rather than silently minting a colliding message id', () => {
+    const store = createTestThreadsStore()
+    const threadId = store.create()
+
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { id: 'p1', type: 'text', text: 'unreachable' }
+      },
+    }
+
+    const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', { value: undefined, configurable: true })
+    try {
+      expect(() => {
+        act(() => {
+          result.current.start(threadId, 'hi')
+        })
+      }).toThrow(/idempotency key/)
+    } finally {
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+
+    // The deliberate divergence documented on mintMessageId: throwing means the write never
+    // happened at all (no half-appended message, no orphaned run entry) rather than silently
+    // dropping content behind a colliding id.
+    expect(store.threads.find((t) => t.id === threadId)?.messages).toHaveLength(0)
+    expect(result.current.runs.has(threadId)).toBe(false)
+  })
+})
+
+// A ThreadsStore double that delegates everything to a real test store EXCEPT appendMessage,
+// which throws for messages matching `shouldThrow` — lets a test simulate consumer-adapter code
+// (appendMessage) throwing without touching the shared createTestThreadsStore factory used by
+// every other test in this file.
+function wrapStoreWithThrowingAppend(
+  store: ThreadsStore<AgentPart>,
+  shouldThrow: (message: AgentThread<AgentPart>['messages'][number]) => boolean,
+): ThreadsStore<AgentPart> {
+  return {
+    get threads() {
+      return store.threads
+    },
+    get activeId() {
+      return store.activeId
+    },
+    select: store.select,
+    create: store.create,
+    appendMessage(id, message) {
+      if (shouldThrow(message)) {
+        throw new Error('consumer appendMessage boom')
+      }
+      store.appendMessage(id, message)
+    },
+    setOutcome: store.setOutcome,
+    setStatus: store.setStatus,
+    setResumeToken: store.setResumeToken,
+    markRead: store.markRead,
+    remove: store.remove,
+    clear: store.clear,
+    hydrated: store.hydrated,
+    error: store.error,
+  }
+}
+
+/** As above, but for the settle half of `finalizeStop` — a consumer store whose `setStatus` throws
+ * (a remote-backed adapter rejecting a thread removed mid-stream is the realistic shape). Narrowed
+ * by `shouldThrow` because the hook ALSO calls `setStatus` from its mount-time orphan sweep, which
+ * is a different call site with a different (non-wedge) failure mode. */
+function wrapStoreWithThrowingSetStatus(
+  store: ThreadsStore<AgentPart>,
+  shouldThrow: (status: AgentThread<AgentPart>['status']) => boolean,
+): ThreadsStore<AgentPart> {
+  return {
+    get threads() {
+      return store.threads
+    },
+    get activeId() {
+      return store.activeId
+    },
+    select: store.select,
+    create: store.create,
+    appendMessage: store.appendMessage,
+    setOutcome: store.setOutcome,
+    setStatus(id, status) {
+      if (shouldThrow(status)) throw new Error('consumer setStatus boom')
+      store.setStatus(id, status)
+    },
+    setResumeToken: store.setResumeToken,
+    markRead: store.markRead,
+    remove: store.remove,
+    clear: store.clear,
+    hydrated: store.hydrated,
+    error: store.error,
+  }
+}
+
+describe('useAgentThreadRuns — finalizeStop must reach a terminal state no matter what', () => {
+  test('stop() on a host with no usable crypto still reaches a terminal status and clears the run entry (was: wedged at "streaming" forever)', async () => {
+    const store = createTestThreadsStore()
+    const threadId = store.create()
+
+    const gate = deferred<void>()
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { id: 'p1', type: 'text', text: 'partial' }
+        await gate.promise
+        yield { id: 'p2', type: 'text', text: 'never arrives' }
+      },
+    }
+
+    const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+    act(() => {
+      result.current.start(threadId, 'hi')
+    })
+
+    await waitFor(() => {
+      expect(result.current.runs.get(threadId)?.parts).toHaveLength(1)
+    })
+
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', { value: undefined, configurable: true })
+    try {
+      act(() => {
+        result.current.stop(threadId)
+      })
+
+      const thread = store.threads.find((t) => t.id === threadId)
+      // Before the fix: mintMessageId's throw escaped finalizeStop entirely, so setStatus/setRuns
+      // never ran and this stayed 'streaming' forever.
+      expect(thread?.status).toBe('error')
+      // The stopped message never minted an id, so appendMessage was never even attempted —
+      // only the original user message is present.
+      expect(thread?.messages).toHaveLength(1)
+      expect(result.current.runs.has(threadId)).toBe(false)
+
+      // A second stop() must not be the user's only recourse — and it isn't: controllersRef
+      // already had this threadId deleted before finalizeStop ever ran, so this is an ordinary
+      // no-op, not a retry of the failed append.
+      act(() => {
+        result.current.stop(threadId)
+      })
+      expect(store.threads.find((t) => t.id === threadId)?.status).toBe('error')
+    } finally {
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+
+    gate.resolve(undefined)
+  })
+
+  test("stop() reaches a terminal status and clears the run entry even when the consumer's appendMessage throws (was: wedged at 'streaming' forever)", async () => {
+    const baseStore = createTestThreadsStore()
+    const threadId = baseStore.create()
+    const store = wrapStoreWithThrowingAppend(
+      baseStore,
+      (message) => message.role === 'assistant' && message.finish === 'stopped',
+    )
+
+    const gate = deferred<void>()
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { id: 'p1', type: 'text', text: 'partial' }
+        await gate.promise
+        yield { id: 'p2', type: 'text', text: 'never arrives' }
+      },
+    }
+
+    const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+    act(() => {
+      result.current.start(threadId, 'hi')
+    })
+
+    await waitFor(() => {
+      expect(result.current.runs.get(threadId)?.parts).toHaveLength(1)
+    })
+
+    act(() => {
+      result.current.stop(threadId)
+    })
+
+    const thread = store.threads.find((t) => t.id === threadId)
+    expect(thread?.status).toBe('error')
+    // Only the user message — the consumer's appendMessage rejected the stopped message.
+    expect(thread?.messages).toHaveLength(1)
+    expect(result.current.runs.has(threadId)).toBe(false)
+
+    // A second stop() remains a true no-op — not the user's only recourse.
+    act(() => {
+      result.current.stop(threadId)
+    })
+    expect(store.threads.find((t) => t.id === threadId)?.status).toBe('error')
+
+    gate.resolve(undefined)
+  })
+
+  test("stop() clears the hook's own run entry even when the consumer's setStatus throws (the second half of the same wedge)", async () => {
+    const baseStore = createTestThreadsStore()
+    const threadId = baseStore.create()
+    const store = wrapStoreWithThrowingSetStatus(baseStore, (status) => status === 'done')
+
+    const gate = deferred<void>()
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { id: 'p1', type: 'text', text: 'partial' }
+        await gate.promise
+        yield { id: 'p2', type: 'text', text: 'never arrives' }
+      },
+    }
+
+    const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+    act(() => {
+      result.current.start(threadId, 'hi')
+    })
+
+    await waitFor(() => {
+      expect(result.current.runs.get(threadId)?.parts).toHaveLength(1)
+    })
+
+    act(() => {
+      result.current.stop(threadId)
+    })
+
+    // The store's own status is whatever the throwing adapter left it as — unrecoverable from
+    // here. What IS this hook's to guarantee is that `runs` no longer reports an in-flight turn:
+    // that entry is the hook's own state and nothing later can ever clear it (stop() already
+    // deleted the thread from controllersRef), so a throw above the teardown stranded it forever.
+    expect(result.current.runs.has(threadId)).toBe(false)
+    // The partial content still landed — the append runs before the settle.
+    expect(store.threads.find((t) => t.id === threadId)?.messages).toHaveLength(2)
+
+    act(() => {
+      result.current.stop(threadId)
+    })
+    expect(result.current.runs.has(threadId)).toBe(false)
+
+    gate.resolve(undefined)
+  })
+
+  test('stop() still succeeds via crypto.getRandomValues when randomUUID is unavailable (rung 2 — the rung that matters in practice)', async () => {
+    const store = createTestThreadsStore()
+    const threadId = store.create()
+
+    const gate = deferred<void>()
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { id: 'p1', type: 'text', text: 'partial' }
+        await gate.promise
+        yield { id: 'p2', type: 'text', text: 'never arrives' }
+      },
+    }
+
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', {
+      value: { getRandomValues: originalCrypto.getRandomValues.bind(originalCrypto) },
+      configurable: true,
+    })
+    try {
+      const { result } = renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+      act(() => {
+        result.current.start(threadId, 'hi')
+      })
+
+      await waitFor(() => {
+        expect(result.current.runs.get(threadId)?.parts).toHaveLength(1)
+      })
+
+      act(() => {
+        result.current.stop(threadId)
+      })
+
+      const thread = store.threads.find((t) => t.id === threadId)
+      expect(thread?.status).toBe('done')
+      expect(thread?.messages).toHaveLength(2)
+      expect(thread?.messages[1]?.finish).toBe('stopped')
+      expect(result.current.runs.has(threadId)).toBe(false)
+    } finally {
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+
+    gate.resolve(undefined)
+  })
+})