basalt-ui 1.9.0 → 1.10.0

package/src/agent/ai-sdk-transport.test.ts

@@ -0,0 +1,269 @@
+/**
+ * aiSdkTransport — snapshot→delta diffing (text/reasoning/source/tool), signal-abort mid-stream,
+ * and deterministic chat-id binding via `.forThread()`.
+ *
+ * Scope: the diffing behaviour AS IT EXISTS TODAY (B1) — no seven-state ToolCallPart, no
+ * `output-error` carrying a dedicated `error` field (today it is smuggled through `output`, see
+ * the `output-error` test below), no `durationMs` on terminal states. Those are 1.10.0 part-
+ * identity work; this file pins the CURRENT shape so that work has a baseline to diff against.
+ *
+ * Driving `aiSdkTransport` through a scripted HTTP response — the only way to exercise its public
+ * stream()/resume() diffing at all, since the diffing internals are not exported — requires a real
+ * web-streams `TransformStream` for `ai`'s HTTP transport and `eventsource-parser` to construct
+ * internally (`DefaultChatTransport.processResponseStream`, `EventSourceParserStream`). The DOM
+ * harness (`tests/setup/dom.ts`, preloaded once per `bun test` process) restores the native
+ * web-stream classes after happy-dom registration, so a plain static `import` here is safe
+ * regardless of file/module evaluation order.
+ */
+import { describe, expect, test } from 'bun:test'
+import { JsonToSseTransformStream } from 'ai'
+import { aiSdkTransport } from './ai-sdk-transport'
+import type { UIMessageChunk } from 'ai'
+import type { AgentPart } from './parts'
+
+/**
+ * Builds a fetch-compatible Response whose body is the given low-level UIMessageChunks, SSE-
+ * encoded exactly as AI SDK's own `DefaultChatTransport` expects (real `JsonToSseTransformStream`,
+ * not a hand-rolled encoding) so this exercises the real parse/diff pipeline end to end.
+ */
+function scriptedResponse(chunks: UIMessageChunk[]): Response {
+  const source = new ReadableStream<UIMessageChunk>({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(chunk)
+      controller.close()
+    },
+  })
+  const body = source
+    .pipeThrough(new JsonToSseTransformStream())
+    .pipeThrough(new TextEncoderStream())
+  return new Response(body, { status: 200, headers: { 'content-type': 'text/event-stream' } })
+}
+
+/** Drains an aiSdkTransport `.stream()`/`.resume()` async generator into a plain array. */
+async function collect(gen: AsyncGenerator<AgentPart>): Promise<AgentPart[]> {
+  const parts: AgentPart[] = []
+  for await (const part of gen) parts.push(part)
+  return parts
+}
+
+describe('aiSdkTransport — snapshot→delta diffing', () => {
+  test('yields a synthesized start part first, then diffs text deltas across snapshots', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'text-start', id: 't1' },
+      { type: 'text-delta', id: 't1', delta: 'Hel' },
+      { type: 'text-delta', id: 't1', delta: 'lo' },
+      { type: 'text-end', id: 't1' },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    expect(parts[0]?.type).toBe('start')
+    const textParts = parts.filter((p): p is { type: 'text'; text: string } => p.type === 'text')
+    // AI SDK's snapshot carries the FULL accumulated text at every write — the module's whole job
+    // is re-deriving the two incremental deltas ('Hel' then 'lo') rather than replaying 'Hello'
+    // twice or once whole.
+    expect(textParts).toEqual([
+      { type: 'text', text: 'Hel' },
+      { type: 'text', text: 'lo' },
+    ])
+    expect(textParts.reduce((acc, p) => acc + p.text, '')).toBe('Hello')
+  })
+
+  test('diffs reasoning deltas the same way as text', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'reasoning-start', id: 'r1' },
+      { type: 'reasoning-delta', id: 'r1', delta: 'thinking ' },
+      { type: 'reasoning-delta', id: 'r1', delta: 'more' },
+      { type: 'reasoning-end', id: 'r1' },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    const reasoningParts = parts.filter((p) => p.type === 'reasoning')
+    expect(reasoningParts).toEqual([
+      { type: 'reasoning', text: 'thinking ' },
+      { type: 'reasoning', text: 'more' },
+    ])
+  })
+
+  test('emits a source part exactly once for a source-url chunk', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'source-url', sourceId: 's1', url: 'https://example.com', title: 'Example' },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    const sourceParts = parts.filter((p) => p.type === 'source')
+    expect(sourceParts).toEqual([{ type: 'source', url: 'https://example.com', title: 'Example' }])
+  })
+
+  test('a tool call progresses input-available → output-available with the accumulated output', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'tool-input-start', toolCallId: 'call-1', toolName: 'search' },
+      { type: 'tool-input-available', toolCallId: 'call-1', toolName: 'search', input: { q: 'x' } },
+      { type: 'tool-output-available', toolCallId: 'call-1', output: { hits: 3 } },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    const toolParts = parts.filter((p) => p.type === 'tool')
+    // input-streaming is never emitted (deliberate v1 simplification) — only input-available then
+    // output-available surface, one AgentPart each.
+    expect(toolParts).toEqual([
+      { type: 'tool', toolName: 'search', toolCallId: 'call-1', input: { q: 'x' } },
+      {
+        type: 'tool',
+        toolName: 'search',
+        toolCallId: 'call-1',
+        input: { q: 'x' },
+        output: { hits: 3 },
+      },
+    ])
+  })
+
+  test('a repeated chunk carrying the SAME tool state is deduped — nothing new to report', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'tool-input-start', toolCallId: 'call-1', toolName: 'search' },
+      { type: 'tool-input-available', toolCallId: 'call-1', toolName: 'search', input: { q: 'x' } },
+      // Redundant re-send of the identical input-available state — must not double-emit.
+      { type: 'tool-input-available', toolCallId: 'call-1', toolName: 'search', input: { q: 'x' } },
+      { type: 'tool-output-available', toolCallId: 'call-1', output: { hits: 3 } },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    const toolParts = parts.filter((p) => p.type === 'tool')
+    expect(toolParts).toHaveLength(2) // input-available once, output-available once — not three
+  })
+
+  // 1.10.0 will give ToolCallPart a dedicated error state/field (the seven-state union named in
+  // this file's scope note). TODAY, ai-sdk-transport.ts:187-188 smuggles a tool failure through
+  // the ordinary `output` field as `{ error: errorText }` — this test pins THAT current shape so
+  // the 1.10.0 change has a documented baseline to diff against.
+  test('output-error is currently smuggled through `output`, not a dedicated error field', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'tool-input-start', toolCallId: 'call-1', toolName: 'search' },
+      { type: 'tool-input-available', toolCallId: 'call-1', toolName: 'search', input: { q: 'x' } },
+      { type: 'tool-output-error', toolCallId: 'call-1', errorText: 'boom' },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const parts = await collect(transport.stream('hi'))
+
+    const toolParts = parts.filter((p) => p.type === 'tool')
+    const failed = toolParts.at(-1)
+    expect(failed).toEqual({
+      type: 'tool',
+      toolName: 'search',
+      toolCallId: 'call-1',
+      input: { q: 'x' },
+      output: { error: 'boom' },
+    })
+  })
+})
+
+describe('aiSdkTransport — signal.aborted stops the yield', () => {
+  test('once the caller aborts, no further parts are yielded even though more remain', async () => {
+    const chunks: UIMessageChunk[] = [
+      { type: 'text-start', id: 't1' },
+      { type: 'text-delta', id: 't1', delta: 'a' },
+      { type: 'text-delta', id: 't1', delta: 'b' },
+      { type: 'text-end', id: 't1' },
+    ]
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: async () => scriptedResponse(chunks),
+    })
+    const controller = new AbortController()
+    const gen = transport.stream('hi', controller.signal)
+
+    const start = await gen.next()
+    expect(start.value).toMatchObject({ type: 'start' })
+    const firstDelta = await gen.next()
+    expect(firstDelta.value).toEqual({ type: 'text', text: 'a' })
+
+    // Let AI SDK's background readUIMessageStream pump (kicked off inside diffChunkStream, and
+    // NOT gated on our own reads) fully settle before aborting — this is inherent to the library,
+    // not to the AgentTransport code under test: aborting while chunks are still in flight through
+    // that pump races diffChunkStream's early return against the pump's own stream teardown. A
+    // short real-time wait avoids exercising that unrelated race so this test isolates exactly
+    // ai-sdk-transport.ts:218's `if (signal?.aborted) return`.
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    controller.abort()
+    const afterAbort = await gen.next()
+    expect(afterAbort.done).toBe(true)
+    expect(afterAbort.value).toBeUndefined()
+  })
+})
+
+describe('aiSdkTransport — deterministic chat-id binding', () => {
+  test('the fixed (non-forThread) transport mints its chat id ONCE, stable across repeated stream() calls', async () => {
+    // Never actually reached — the synthesized StartPart is yielded before any fetch call, so a
+    // generator that never advances past its first `.next()` never touches the network.
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: () => {
+        throw new Error('must not be called — only the first, pre-network yield is read')
+      },
+    })
+
+    const first = await transport.stream('a').next()
+    const second = await transport.stream('b').next()
+    expect(first.value).toEqual(second.value)
+    expect((first.value as { runId: string }).runId).toBe((second.value as { runId: string }).runId)
+  })
+
+  test('.forThread(id) binds the StartPart runId/resumeToken deterministically to the given id', async () => {
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: () => {
+        throw new Error('must not be called — only the first, pre-network yield is read')
+      },
+    })
+    const bound = transport.forThread('caller-supplied-thread-id')
+
+    const first = await bound.stream('first turn').next()
+    const second = await bound.stream('second turn').next()
+
+    expect(first.value).toEqual({
+      type: 'start',
+      runId: 'caller-supplied-thread-id',
+      resumeToken: 'caller-supplied-thread-id',
+    })
+    // Same across repeated turns on the same bound transport — the id is NOT re-minted per call.
+    expect(second.value).toEqual(first.value)
+  })
+
+  test('two different .forThread() ids produce two different StartPart runIds', async () => {
+    const transport = aiSdkTransport({
+      api: '/api/chat',
+      fetch: () => {
+        throw new Error('must not be called — only the first, pre-network yield is read')
+      },
+    })
+
+    const a = await transport.forThread('thread-a').stream('hi').next()
+    const b = await transport.forThread('thread-b').stream('hi').next()
+
+    expect(a.value).toEqual({ type: 'start', runId: 'thread-a', resumeToken: 'thread-a' })
+    expect(b.value).toEqual({ type: 'start', runId: 'thread-b', resumeToken: 'thread-b' })
+  })
+})

package/src/agent/parts.test.ts

@@ -0,0 +1,261 @@
+/**
+ * parseAgentPart / isStartPart — the runtime narrowing guard over the AgentPart wire format.
+ *
+ * Scope: the parser AS IT EXISTS TODAY (B1) — no required `id`/`toolCallId`, no `AgentPartDraft`,
+ * no seven-state ToolCallPart union; those are 1.10.0 part-identity work landing on top of this
+ * currently-untested parser (see the sibling `ai-sdk-transport.test.ts`'s scope note for the same
+ * cutoff). Every AgentPart variant below is validated against parts.ts:87's `parseAgentPart` and
+ * parts.ts:134's `isStartPart` as they read right now.
+ */
+import { describe, expect, test } from 'bun:test'
+import { isStartPart, parseAgentPart } from './parts'
+import type { AgentPart } from './parts'
+
+/** JSON round-trip a value through JSON.stringify → JSON.parse, mirroring wire transport. */
+function roundTrip(value: unknown): unknown {
+  return JSON.parse(JSON.stringify(value))
+}
+
+describe('parseAgentPart', () => {
+  describe('start', () => {
+    test('parses a minimal start part (no resumeToken)', () => {
+      const raw = { type: 'start', runId: 'run-1' }
+      expect(parseAgentPart(raw)).toEqual({ type: 'start', runId: 'run-1' })
+    })
+
+    test('parses a start part with resumeToken', () => {
+      const raw = { type: 'start', runId: 'run-1', resumeToken: 'tok-1' }
+      expect(parseAgentPart(raw)).toEqual({
+        type: 'start',
+        runId: 'run-1',
+        resumeToken: 'tok-1',
+      })
+    })
+
+    test('drops a non-string resumeToken rather than passing it through', () => {
+      const raw = { type: 'start', runId: 'run-1', resumeToken: 42 }
+      expect(parseAgentPart(raw)).toEqual({ type: 'start', runId: 'run-1' })
+    })
+
+    test('rejects a missing runId', () => {
+      expect(parseAgentPart({ type: 'start' })).toBeNull()
+    })
+
+    test('rejects a non-string runId', () => {
+      expect(parseAgentPart({ type: 'start', runId: 42 })).toBeNull()
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = { type: 'start', runId: 'run-1', resumeToken: 'tok-1' }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('text', () => {
+    test('parses a text part', () => {
+      expect(parseAgentPart({ type: 'text', text: 'hello' })).toEqual({
+        type: 'text',
+        text: 'hello',
+      })
+    })
+
+    test('rejects a missing text field', () => {
+      expect(parseAgentPart({ type: 'text' })).toBeNull()
+    })
+
+    test('rejects a non-string text field', () => {
+      expect(parseAgentPart({ type: 'text', text: 1 })).toBeNull()
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = { type: 'text', text: 'hello' }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('reasoning', () => {
+    test('parses a reasoning part', () => {
+      expect(parseAgentPart({ type: 'reasoning', text: 'thinking...' })).toEqual({
+        type: 'reasoning',
+        text: 'thinking...',
+      })
+    })
+
+    test('rejects a missing text field', () => {
+      expect(parseAgentPart({ type: 'reasoning' })).toBeNull()
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = { type: 'reasoning', text: 'thinking...' }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('tool', () => {
+    test('parses a minimal tool part (input only, no output/toolCallId)', () => {
+      const raw = { type: 'tool', toolName: 'search', input: { q: 'x' } }
+      expect(parseAgentPart(raw)).toEqual({
+        type: 'tool',
+        toolName: 'search',
+        input: { q: 'x' },
+      })
+    })
+
+    test('parses a tool part with output and toolCallId', () => {
+      const raw = {
+        type: 'tool',
+        toolName: 'search',
+        input: { q: 'x' },
+        output: { hits: 3 },
+        toolCallId: 'call-1',
+      }
+      expect(parseAgentPart(raw)).toEqual({
+        type: 'tool',
+        toolName: 'search',
+        input: { q: 'x' },
+        output: { hits: 3 },
+        toolCallId: 'call-1',
+      })
+    })
+
+    test('rejects a missing toolName', () => {
+      expect(parseAgentPart({ type: 'tool', input: {} })).toBeNull()
+    })
+
+    test('rejects a non-string toolName', () => {
+      expect(parseAgentPart({ type: 'tool', toolName: 1, input: {} })).toBeNull()
+    })
+
+    test('rejects a missing input key entirely (undefined input is a valid value, absent key is not)', () => {
+      expect(parseAgentPart({ type: 'tool', toolName: 'search' })).toBeNull()
+    })
+
+    test('accepts an explicit `input: undefined` (the key is present)', () => {
+      const raw = { type: 'tool', toolName: 'search', input: undefined }
+      expect(parseAgentPart(raw)).toEqual({ type: 'tool', toolName: 'search', input: undefined })
+    })
+
+    test('drops a non-string toolCallId rather than passing it through', () => {
+      const raw = { type: 'tool', toolName: 'search', input: {}, toolCallId: 7 }
+      expect(parseAgentPart(raw)).toEqual({ type: 'tool', toolName: 'search', input: {} })
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = {
+        type: 'tool',
+        toolName: 'search',
+        input: { q: 'x' },
+        output: { hits: 3 },
+        toolCallId: 'call-1',
+      }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('source', () => {
+    test('parses a minimal source part (no title)', () => {
+      expect(parseAgentPart({ type: 'source', url: 'https://example.com' })).toEqual({
+        type: 'source',
+        url: 'https://example.com',
+      })
+    })
+
+    test('parses a source part with title', () => {
+      const raw = { type: 'source', url: 'https://example.com', title: 'Example' }
+      expect(parseAgentPart(raw)).toEqual({
+        type: 'source',
+        url: 'https://example.com',
+        title: 'Example',
+      })
+    })
+
+    test('rejects a missing url', () => {
+      expect(parseAgentPart({ type: 'source' })).toBeNull()
+    })
+
+    test('drops a non-string title rather than passing it through', () => {
+      const raw = { type: 'source', url: 'https://example.com', title: 7 }
+      expect(parseAgentPart(raw)).toEqual({ type: 'source', url: 'https://example.com' })
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = { type: 'source', url: 'https://example.com', title: 'Example' }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('error', () => {
+    test('parses an error part', () => {
+      expect(parseAgentPart({ type: 'error', message: 'boom' })).toEqual({
+        type: 'error',
+        message: 'boom',
+      })
+    })
+
+    test('rejects a missing message', () => {
+      expect(parseAgentPart({ type: 'error' })).toBeNull()
+    })
+
+    test('rejects a non-string message', () => {
+      expect(parseAgentPart({ type: 'error', message: 500 })).toBeNull()
+    })
+
+    test('round-trips through JSON', () => {
+      const part: AgentPart = { type: 'error', message: 'boom' }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+  })
+
+  describe('malformed input', () => {
+    test('rejects null', () => {
+      expect(parseAgentPart(null)).toBeNull()
+    })
+
+    test('rejects a non-object primitive (string)', () => {
+      expect(parseAgentPart('not a part')).toBeNull()
+    })
+
+    test('rejects a non-object primitive (number)', () => {
+      expect(parseAgentPart(42)).toBeNull()
+    })
+
+    test('rejects an array', () => {
+      // Arrays are `typeof 'object'` but have no `type` string key — falls through the same guard.
+      expect(parseAgentPart([1, 2, 3])).toBeNull()
+    })
+
+    test('rejects an object with no type field', () => {
+      expect(parseAgentPart({ text: 'hello' })).toBeNull()
+    })
+
+    test('rejects an object with a non-string type field', () => {
+      expect(parseAgentPart({ type: 1 })).toBeNull()
+    })
+
+    test('rejects an unknown type discriminant', () => {
+      expect(parseAgentPart({ type: 'unknown-variant', text: 'hi' })).toBeNull()
+    })
+  })
+})
+
+describe('isStartPart', () => {
+  test('returns true for a StartPart', () => {
+    expect(isStartPart({ type: 'start', runId: 'run-1' })).toBe(true)
+  })
+
+  test('returns false for a non-start AgentPart', () => {
+    expect(isStartPart({ type: 'text', text: 'hi' })).toBe(false)
+  })
+
+  test('returns false for null', () => {
+    expect(isStartPart(null)).toBe(false)
+  })
+
+  test('returns false for a non-object primitive', () => {
+    expect(isStartPart('start')).toBe(false)
+  })
+
+  test('returns false for an object with no type field', () => {
+    expect(isStartPart({ runId: 'run-1' })).toBe(false)
+  })
+})

package/src/agent/thread.test.ts

@@ -0,0 +1,147 @@
+/**
+ * createThreadsStore — ring-buffer caps (maxThreads/maxMessagesPerThread), newest-first ordering,
+ * setResumeToken's delete-the-key-on-undefined semantics, and same-tick action accumulation.
+ *
+ * Uses the REAL localStorage-backed store (happy-dom provides `window.localStorage`), so every
+ * test uses its own unique `key` — the same convention as
+ * `router-tanstack/multi-search-param-store.test.ts` — to avoid cross-test bleed through the
+ * shared localStorage instance the process-wide DOM registration provides.
+ */
+import { describe, expect, test } from 'bun:test'
+import { act, renderHook } from '@testing-library/react'
+import { createThreadsStore } from './thread'
+import type { ChatMessage } from './history'
+
+function makeMessage(id: string): ChatMessage {
+  return { id, role: 'user', parts: [{ type: 'text', text: id }], createdAt: Date.now() }
+}
+
+describe('createThreadsStore', () => {
+  test('caps at 50 threads, dropping the oldest (tail) when exceeded', () => {
+    const useThreads = createThreadsStore({ key: 'thread-cap-a', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    const ids: string[] = []
+    act(() => {
+      for (let i = 0; i < 51; i++) {
+        ids.push(result.current.create())
+      }
+    })
+
+    expect(result.current.threads).toHaveLength(50)
+    // The very first created thread is the oldest — it must have been dropped.
+    expect(result.current.threads.some((t) => t.id === ids[0])).toBe(false)
+    // The very last created thread is the newest — it must be retained, at index 0.
+    expect(result.current.threads[0]?.id).toBe(ids[50])
+  })
+
+  test('caps at 100 messages per thread, dropping the oldest first', () => {
+    const useThreads = createThreadsStore({ key: 'thread-cap-b', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    let threadId = ''
+    act(() => {
+      threadId = result.current.create()
+    })
+
+    act(() => {
+      for (let i = 0; i < 101; i++) {
+        result.current.appendMessage(threadId, makeMessage(`m${i}`))
+      }
+    })
+
+    const thread = result.current.threads.find((t) => t.id === threadId)
+    expect(thread?.messages).toHaveLength(100)
+    // m0 (the oldest) must have been dropped; m1..m100 survive.
+    expect(thread?.messages[0]?.id).toBe('m1')
+    expect(thread?.messages.at(-1)?.id).toBe('m100')
+  })
+
+  test('threads are stored newest-first: the most recently created thread is always index 0', () => {
+    const useThreads = createThreadsStore({ key: 'thread-order-a', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    let idA = ''
+    let idB = ''
+    let idC = ''
+    act(() => {
+      idA = result.current.create()
+    })
+    act(() => {
+      idB = result.current.create()
+    })
+    act(() => {
+      idC = result.current.create()
+    })
+
+    expect(result.current.threads.map((t) => t.id)).toEqual([idC, idB, idA])
+  })
+
+  test('setResumeToken(id, undefined) deletes the key rather than assigning undefined', () => {
+    const useThreads = createThreadsStore({ key: 'thread-resume-a', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    let threadId = ''
+    act(() => {
+      threadId = result.current.create()
+    })
+
+    act(() => {
+      result.current.setResumeToken(threadId, 'token-1')
+    })
+    const withToken = result.current.threads.find((t) => t.id === threadId)
+    expect(withToken?.resumeToken).toBe('token-1')
+    expect('resumeToken' in (withToken ?? {})).toBe(true)
+    // JSON round-trip: the key is present and serialized.
+    expect(JSON.parse(JSON.stringify(withToken)).resumeToken).toBe('token-1')
+
+    act(() => {
+      result.current.setResumeToken(threadId, undefined)
+    })
+    const cleared = result.current.threads.find((t) => t.id === threadId)
+    // The distinction this test pins: the key is ABSENT, not present-with-value-undefined —
+    // observable via `in` (survives a plain assignment of `undefined`) and via JSON round-trip
+    // (an `undefined`-valued key would also vanish from JSON, so `in` is the load-bearing check).
+    expect('resumeToken' in (cleared ?? {})).toBe(false)
+    expect(cleared?.resumeToken).toBeUndefined()
+    expect(JSON.stringify(cleared)).not.toContain('resumeToken')
+  })
+
+  test('two synchronous actions called in the same tick accumulate rather than one clobbering the other', () => {
+    const useThreads = createThreadsStore({ key: 'thread-accumulate-a', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    let threadId = ''
+    act(() => {
+      // Both calls happen before React re-renders and hands back a fresh `result.current` — the
+      // second call must still observe the first's effect via the ref mirror (thread.ts:178-190),
+      // not the stale pre-render `state` closure.
+      threadId = result.current.create()
+      result.current.appendMessage(threadId, makeMessage('accumulated'))
+    })
+
+    const thread = result.current.threads.find((t) => t.id === threadId)
+    expect(thread).toBeDefined()
+    expect(thread?.messages).toHaveLength(1)
+    expect(thread?.messages[0]?.id).toBe('accumulated')
+  })
+
+  test('two synchronous setStatus + setResumeToken calls in one tick both land, not just the last', () => {
+    const useThreads = createThreadsStore({ key: 'thread-accumulate-b', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    let threadId = ''
+    act(() => {
+      threadId = result.current.create()
+    })
+
+    act(() => {
+      result.current.setStatus(threadId, 'streaming')
+      result.current.setResumeToken(threadId, 'tok-accum')
+    })
+
+    const thread = result.current.threads.find((t) => t.id === threadId)
+    expect(thread?.status).toBe('streaming')
+    expect(thread?.resumeToken).toBe('tok-accum')
+  })
+})