basalt-ui 1.10.0 → 1.11.0

package/src/agent/use-agent-stream.test.tsx

@@ -26,10 +26,10 @@ describe('useAgentStream', () => {
     const gate = deferred<void>()
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
-        yield { type: 'text', text: 'a' }
+        yield { id: 'p1', type: 'text', text: 'a' }
         await gate.promise
         // Must never be observed — the consumer's guard should discard this once aborted.
-        yield { type: 'text', text: 'b' }
+        yield { id: 'p2', type: 'text', text: 'b' }
       },
     }
 
@@ -39,7 +39,7 @@ describe('useAgentStream', () => {
       void result.current.send('hi')
     })
     await waitFor(() => {
-      expect(result.current.parts).toEqual([{ type: 'text', text: 'a' }])
+      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
     })
     expect(result.current.status).toBe('streaming')
 
@@ -53,7 +53,7 @@ describe('useAgentStream', () => {
     await waitFor(() => {
       expect(result.current.status).toBe('done')
     })
-    expect(result.current.parts).toEqual([{ type: 'text', text: 'a' }])
+    expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
   })
 
   test("a second send() supersedes an in-flight one — the first stream's later parts are discarded", async () => {
@@ -61,12 +61,12 @@ describe('useAgentStream', () => {
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(input) {
         if (input === 'first') {
-          yield { type: 'text', text: 'first-1' }
+          yield { id: 'f1', type: 'text', text: 'first-1' }
           await gateFirst.promise
           // Must never be observed — 'second' has already superseded this controller.
-          yield { type: 'text', text: 'first-2' }
+          yield { id: 'f2', type: 'text', text: 'first-2' }
         } else {
-          yield { type: 'text', text: 'second-1' }
+          yield { id: 's1', type: 'text', text: 'second-1' }
         }
       },
     }
@@ -77,14 +77,14 @@ describe('useAgentStream', () => {
       void result.current.send('first')
     })
     await waitFor(() => {
-      expect(result.current.parts).toEqual([{ type: 'text', text: 'first-1' }])
+      expect(result.current.parts).toEqual([{ id: 'f1', type: 'text', text: 'first-1' }])
     })
 
     act(() => {
       void result.current.send('second')
     })
     await waitFor(() => {
-      expect(result.current.parts).toEqual([{ type: 'text', text: 'second-1' }])
+      expect(result.current.parts).toEqual([{ id: 's1', type: 'text', text: 'second-1' }])
     })
     expect(result.current.status).toBe('done')
 
@@ -92,7 +92,37 @@ describe('useAgentStream', () => {
     await waitFor(() => {
       expect(result.current.status).toBe('done')
     })
-    expect(result.current.parts).toEqual([{ type: 'text', text: 'second-1' }])
+    expect(result.current.parts).toEqual([{ id: 's1', type: 'text', text: 'second-1' }])
+  })
+
+  test('F1 regression: id-less drafts of different types within one send() do not destroy each other', async () => {
+    const transport: AgentTransport<AgentPart, string> = {
+      async *stream() {
+        yield { type: 'text', text: 'Hi' }
+        yield {
+          type: 'tool',
+          toolCallId: 'c1',
+          toolName: 'search',
+          state: 'input-available',
+          input: { q: 'x' },
+        }
+        yield { type: 'text', text: 'Bye' }
+      },
+    }
+
+    const { result } = renderHook(() => useAgentStream({ transport }))
+
+    await act(async () => {
+      await result.current.send('hi')
+    })
+
+    // Pre-fix: mergePart matched all three drafts on `undefined === undefined`, so text→tool→text
+    // collapsed to a single (wrong-typed) entry instead of three. withPartIds stamping a distinct
+    // id per draft is what keeps them apart.
+    expect(result.current.parts).toHaveLength(3)
+    expect(result.current.parts.map((part) => part.type)).toEqual(['text', 'tool', 'text'])
+    const ids = result.current.parts.map((part) => (part as { id: string }).id)
+    expect(new Set(ids).size).toBe(3)
   })
 
   test('a thrown (non-abort) error sets status "error" and captures the error', async () => {
@@ -119,10 +149,10 @@ describe('useAgentStream', () => {
     const gate = deferred<void>()
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(_input, signal) {
-        yield { type: 'text', text: 'a' }
+        yield { id: 'p1', type: 'text', text: 'a' }
         await gate.promise
         if (signal?.aborted) throw new DOMException('The operation was aborted.', 'AbortError')
-        yield { type: 'text', text: 'b' }
+        yield { id: 'p2', type: 'text', text: 'b' }
       },
     }
 
@@ -132,7 +162,7 @@ describe('useAgentStream', () => {
       void result.current.send('hi')
     })
     await waitFor(() => {
-      expect(result.current.parts).toEqual([{ type: 'text', text: 'a' }])
+      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
     })
 
     // stop() aborts the signal AND sets 'done' synchronously.
@@ -155,7 +185,7 @@ describe('useAgentStream', () => {
     const gate = deferred<void>()
     const transport: AgentTransport<AgentPart, string> = {
       async *stream(_input, signal) {
-        yield { type: 'text', text: 'a' }
+        yield { id: 'p1', type: 'text', text: 'a' }
         await gate.promise
         observedAbortedOnResume = signal?.aborted ?? false
       },
@@ -167,7 +197,7 @@ describe('useAgentStream', () => {
       void result.current.send('hi')
     })
     await waitFor(() => {
-      expect(result.current.parts).toEqual([{ type: 'text', text: 'a' }])
+      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
     })
 
     unmount()
@@ -197,7 +227,7 @@ describe('useAgentStream', () => {
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {
         streamCalls++
-        yield { type: 'text', text: `call-${streamCalls}` }
+        yield { id: `call-${streamCalls}`, type: 'text', text: `call-${streamCalls}` }
       },
     }
 
@@ -226,6 +256,6 @@ describe('useAgentStream', () => {
 
     expect(streamCalls).toBe(2)
     // Only the SECOND (surviving) call's part made it into final state — the first is discarded.
-    expect(capturedParts).toEqual([{ type: 'text', text: 'call-2' }])
+    expect(capturedParts).toEqual([{ id: 'call-2', type: 'text', text: 'call-2' }])
   })
 })

package/src/agent/use-agent-stream.ts

@@ -27,7 +27,10 @@
  * }
  */
 import { useCallback, useEffect, useRef, useState } from 'react'
+import { withPartIds } from './id'
 import { isStartPart } from './parts'
+import { mergePart } from './merge'
+import type { PartLike } from './merge'
 import type { AgentPart } from './parts'
 import type { AgentTransport } from './transport'
 
@@ -67,7 +70,7 @@ export type UseAgentStreamReturn<TPart, TInput> = {
  * // parts accumulates as the stream arrives
  * // status: 'idle' → 'streaming' → 'done' (or 'error')
  */
-export function useAgentStream<TPart = AgentPart, TInput = string>({
+export function useAgentStream<TPart extends PartLike = AgentPart, TInput = string>({
   transport,
 }: {
   transport: AgentTransport<TPart, TInput>
@@ -100,15 +103,22 @@ export function useAgentStream<TPart = AgentPart, TInput = string>({
       setError(undefined)
       setStatus('streaming')
 
+      // Per-send namespace: this hook has no thread/session id to key off, and each send() call
+      // fully resets `parts` anyway, so a fresh id per call is enough to keep two id-less drafts
+      // ARRIVING WITHIN THE SAME SEND from colliding on `undefined === undefined` in mergePart (the
+      // F1 bug — text→tool→text destroying each other). Not a replay mechanism — this hook has no
+      // resume() path — see withPartIds' own doc for why it can't be one anyway.
+      const runId = crypto.randomUUID()
+
       try {
-        for await (const part of transport.stream(input, controller.signal)) {
+        for await (const part of withPartIds(runId, transport.stream(input, controller.signal))) {
           // Guard: if a newer send() has superseded this stream, stop updating state.
           if (controllerRef.current !== controller) return
           if (controller.signal.aborted) break
           // StartPart is a no-op signal (run id + resume token), not renderable content — this
           // hook has no persistence layer to resume across, so just skip it.
           if (isStartPart(part)) continue
-          setParts((prev) => [...prev, part])
+          setParts((prev) => mergePart(prev, part))
         }
         // Only mark done if this stream is still the current one and wasn't aborted.
         if (controllerRef.current === controller && !controller.signal.aborted) setStatus('done')

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

@@ -0,0 +1,133 @@
+/**
+ * useAgentThreadRuns — foreign-part round trip (B2 convergence fix).
+ *
+ * The open part registry (./foreign) only serves its headline purpose — a transport streaming an
+ * app-specific part type (`data-toolProgress`, `data-chart`, …) reaching `ThreadTranscript` — if a
+ * ForeignPart can flow all the way through this hook's mergePart accumulator: transport →
+ * consumeAndFinalize → runs.get(id).parts → the persisted assistant ChatMessage. This file proves
+ * that path end to end with `useAgentThreadRuns<TranscriptPart>`, which was a tsc error before
+ * mergePart's constraint was widened from `AgentPart` to the structural `PartLike`.
+ */
+import { describe, expect, test } from 'bun:test'
+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 { TranscriptPart } from './foreign'
+import type { AgentOutcome, OutcomeResolver } from './outcome'
+
+// ── test-only ThreadsStore double, typed over TranscriptPart ─────────────────────────────────────
+function createTestThreadsStore(): ThreadsStore<TranscriptPart> {
+  let threads: AgentThread<TranscriptPart>[] = []
+  let activeId: string | null = null
+
+  return {
+    get threads() {
+      return threads
+    },
+    get activeId() {
+      return activeId
+    },
+    select(id) {
+      activeId = id
+    },
+    create(createOpts) {
+      const id = crypto.randomUUID()
+      const now = Date.now()
+      const thread: AgentThread<TranscriptPart> = {
+        id,
+        messages: [],
+        outcome: null,
+        status: 'pending',
+        read: false,
+        createdAt: now,
+        updatedAt: now,
+        ...(createOpts?.meta !== undefined ? { meta: createOpts.meta } : {}),
+      }
+      threads = [thread, ...threads]
+      return id
+    },
+    appendMessage(id, message) {
+      threads = threads.map((thread) =>
+        thread.id === id
+          ? { ...thread, messages: [...thread.messages, message], updatedAt: Date.now() }
+          : thread,
+      )
+    },
+    setOutcome(id, outcome) {
+      threads = threads.map((thread) =>
+        thread.id === id ? { ...thread, outcome, updatedAt: Date.now() } : thread,
+      )
+    },
+    setStatus(id, status) {
+      threads = threads.map((thread) =>
+        thread.id === id ? { ...thread, status, updatedAt: Date.now() } : thread,
+      )
+    },
+    setResumeToken(id, token) {
+      threads = threads.map((thread) => {
+        if (thread.id !== id) return thread
+        const { resumeToken: _resumeToken, ...rest } = thread
+        return {
+          ...rest,
+          ...(token !== undefined ? { resumeToken: token } : {}),
+          updatedAt: Date.now(),
+        }
+      })
+    },
+    markRead(id) {
+      threads = threads.map((thread) => (thread.id === id ? { ...thread, read: true } : thread))
+    },
+    remove(id) {
+      threads = threads.filter((thread) => thread.id !== id)
+      if (activeId === id) activeId = null
+    },
+    clear() {
+      threads = []
+      activeId = null
+    },
+  }
+}
+
+const resolveOutcome: OutcomeResolver<TranscriptPart> = (): AgentOutcome => ({
+  title: 'title',
+  summary: 'summary',
+  status: 'done',
+})
+
+describe('useAgentThreadRuns<TranscriptPart> — foreign part round trip', () => {
+  test('a foreign part survives accumulation and a replay replaces rather than duplicates', async () => {
+    const store = createTestThreadsStore()
+    const threadId = store.create()
+
+    const transport: AgentTransport<TranscriptPart, string> = {
+      async *stream() {
+        yield { id: 'progress-1', type: 'data-toolProgress', message: 'searching' }
+        // Same id, second delta — must REPLACE the first entry, not duplicate it.
+        yield { id: 'progress-1', type: 'data-toolProgress', message: 'done' }
+        yield { id: 'text-1', type: 'text', text: 'Found it.' }
+      },
+    }
+
+    const { result } = renderHook(() =>
+      useAgentThreadRuns<TranscriptPart>({ transport, store, resolveOutcome }),
+    )
+
+    act(() => {
+      result.current.start(threadId, 'go find it')
+    })
+
+    await waitFor(() => {
+      expect(store.threads.find((t) => t.id === threadId)?.status).toBe('done')
+    })
+
+    const assistantMessage = store.threads
+      .find((t) => t.id === threadId)
+      ?.messages.find((m) => m.role === 'assistant')
+
+    expect(assistantMessage?.parts).toEqual([
+      { id: 'progress-1', type: 'data-toolProgress', message: 'done' },
+      { id: 'text-1', type: 'text', text: 'Found it.' },
+    ])
+  })
+})

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

@@ -4,8 +4,10 @@
  * The mount-reconcile effect (empty deps — a one-time sweep of whatever the store held when this
  * manager first attaches) treats any persisted 'pending' or 'streaming' thread with no live
  * controller as orphaned, and either attempts `transport.resume(resumeToken, signal)` (when the
- * transport supports it, a resumeToken is present, and there's a last user message to attribute
- * the resumed turn to) or falls back straight to 'interrupted'.
+ * transport is RESUMABLE per `isResumable` — `resume` AND the literal `idempotentReplay: true`
+ * assertion, a resumeToken is present, and there's a last user message to attribute the resumed
+ * turn to) or falls back straight to 'interrupted'. `resume` alone is NOT enough post-B2 — see the
+ * dedicated "resume() present but no idempotentReplay" test below.
  *
  * The F3 wedge (StrictMode/`<Activity>` re-running this same effect on the SAME fiber) has its
  * own file: `use-agent-thread-runs.wedge.test.tsx`.
@@ -155,12 +157,13 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const store = createTestThreadsStore([thread])
 
     let resumeCalls = 0
-    const transport: AgentTransport<AgentPart, string> = {
+    const transport = {
       async *stream() {},
       async *resume() {
         resumeCalls++
         yield { type: 'text', text: 'resumed' }
       },
+      idempotentReplay: true as const,
     }
 
     renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
@@ -175,6 +178,28 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const thread = makeStreamingThread({ messages: [] })
     const store = createTestThreadsStore([thread])
 
+    let resumeCalls = 0
+    const transport = {
+      async *stream() {},
+      async *resume() {
+        resumeCalls++
+        yield { type: 'text', text: 'resumed' }
+      },
+      idempotentReplay: true as const,
+    }
+
+    renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
+
+    await waitFor(() => {
+      expect(store.threads.find((t) => t.id === thread.id)?.status).toBe('interrupted')
+    })
+    expect(resumeCalls).toBe(0)
+  })
+
+  test('resume() present but WITHOUT idempotentReplay → still falls back to interrupted (resume alone is not enough post-B2)', async () => {
+    const thread = makeStreamingThread()
+    const store = createTestThreadsStore([thread])
+
     let resumeCalls = 0
     const transport: AgentTransport<AgentPart, string> = {
       async *stream() {},
@@ -182,6 +207,7 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
         resumeCalls++
         yield { type: 'text', text: 'resumed' }
       },
+      // deliberately NO idempotentReplay: true
     }
 
     renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
@@ -197,12 +223,13 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const store = createTestThreadsStore([thread])
 
     const resumeArgs: string[] = []
-    const transport: AgentTransport<AgentPart, string> = {
+    const transport = {
       async *stream() {},
-      async *resume(token) {
+      async *resume(token: string) {
         resumeArgs.push(token)
         yield { type: 'text', text: 'resumed' }
       },
+      idempotentReplay: true as const,
     }
 
     renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))
@@ -217,12 +244,13 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const thread = makeStreamingThread()
     const store = createTestThreadsStore([thread])
 
-    const transport: AgentTransport<AgentPart, string> = {
+    const transport = {
       async *stream() {},
       // oxlint-disable-next-line require-yield
       async *resume() {
         throw new Error('resume failed')
       },
+      idempotentReplay: true as const,
     }
 
     renderHook(() => useAgentThreadRuns({ transport, store, resolveOutcome }))