basalt-ui 1.11.0 → 1.12.0

package/src/agent/parts.test.ts

@@ -3,14 +3,16 @@
  * AgentPart wire format, post-1.11.0 part identity + the seven-state ToolCallPart union.
  *
  * Every AgentPart variant below is validated against parts.ts's `parseAgentPart`, `isStartPart`,
- * and `isToolCallSettled` as they read right now: `id` is required on every variant, and `tool`
- * parts are validated against the seven-state discriminated union mirroring AI SDK v7's
+ * and `isToolCallSettled` as they read right now: `id` is required on every variant, `toolCallId`
+ * is required on the three in-flight tool states and optional on the four settled ones (see the
+ * per-state identity block below), and `tool` parts are validated against the seven-state
+ * discriminated union mirroring AI SDK v7's
  * `UIToolInvocation` (see parts.ts's ToolCallPart doc for the ground-truth corrections against the
  * design spec).
  */
 import { describe, expect, test } from 'bun:test'
 import { isStartPart, isToolCallSettled, parseAgentPart } from './parts'
-import type { AgentPart, ToolCallPart } from './parts'
+import type { AgentPart, ToolCallPart, ToolCallState } from './parts'
 
 /** JSON round-trip a value through JSON.stringify → JSON.parse, mirroring wire transport. */
 function roundTrip(value: unknown): unknown {
@@ -109,10 +111,11 @@ describe('parseAgentPart', () => {
   })
 
   describe('tool', () => {
-    test('rejects a missing toolCallId', () => {
+    test('rejects a non-string toolCallId', () => {
       const raw = {
         id: 'p1',
         type: 'tool',
+        toolCallId: 42,
         toolName: 'search',
         state: 'input-available',
         input: {},
@@ -120,6 +123,120 @@ describe('parseAgentPart', () => {
       expect(parseAgentPart(raw)).toBeNull()
     })
 
+    // ── toolCallId identity, decided per state ──────────────────────────────
+    // An empty string is not a value any state accepts: '' normalizes to absent right here, so the
+    // pre-1.12.0 sentinel can never reach the type or a consumer of it. What an ABSENT id then
+    // means is a per-state decision (see Identified / MaybeIdentified in parts.ts):
+    //   in-flight  (input-streaming, input-available, approval-requested) → REJECTED. The part
+    //     exists only to be closed by a later state, which re-supplies its toolName and input;
+    //     unidentified it could never be closed and would render as a forever-pending chip.
+    //   settled    (approval-responded + the three terminal states)       → KEPT, unidentified.
+    //     It carries the OUTCOME; dropping it would erase how the call ended (silent data loss),
+    //     while keeping it costs only the fold — coalesceParts renders it as its own block.
+    //
+    // The `satisfies Record<ToolCallState, …>` below is an authoring-time exhaustiveness gate: add
+    // a state to the union and this fixture stops typechecking until its identity behaviour is
+    // decided here too. It is an EDITOR/tsc guard only — the package tsconfig excludes `*.test.ts`
+    // from `bun run typecheck`, and `bun test` type-strips rather than typechecks — so the
+    // "covers every state exactly once" test below backs it with a runtime check of the same claim.
+
+    const UNIDENTIFIED_RAW = {
+      'input-streaming': { toolName: 'search', state: 'input-streaming' },
+      'input-available': { toolName: 'search', state: 'input-available', input: { q: 'x' } },
+      'approval-requested': {
+        toolName: 'search',
+        state: 'approval-requested',
+        input: { q: 'x' },
+        approval: { id: 'appr-1' },
+      },
+      'approval-responded': {
+        toolName: 'search',
+        state: 'approval-responded',
+        input: { q: 'x' },
+        approval: { id: 'appr-1', approved: true },
+      },
+      'output-available': {
+        toolName: 'search',
+        state: 'output-available',
+        input: { q: 'x' },
+        output: { hits: 3 },
+      },
+      'output-error': { toolName: 'search', state: 'output-error', errorText: 'boom' },
+      'output-denied': {
+        toolName: 'search',
+        state: 'output-denied',
+        input: { q: 'x' },
+        approval: { id: 'appr-1', approved: false },
+      },
+    } satisfies Record<ToolCallState, Record<string, unknown>>
+
+    const IN_FLIGHT_STATES = [
+      'input-streaming',
+      'input-available',
+      'approval-requested',
+    ] as const satisfies readonly ToolCallState[]
+
+    const SETTLED_STATES = [
+      'approval-responded',
+      'output-available',
+      'output-error',
+      'output-denied',
+    ] as const satisfies readonly ToolCallState[]
+
+    test('the in-flight/settled split covers every tool state exactly once', () => {
+      // Object.keys() is always typed string[] regardless of the object's key type — cast back to
+      // ToolCallState[], which every key of UNIDENTIFIED_RAW genuinely is (used as
+      // UNIDENTIFIED_RAW[state] elsewhere in this file).
+      expect([...IN_FLIGHT_STATES, ...SETTLED_STATES].toSorted()).toEqual(
+        (Object.keys(UNIDENTIFIED_RAW) as ToolCallState[]).toSorted(),
+      )
+    })
+
+    for (const state of IN_FLIGHT_STATES) {
+      test(`${state}: rejects a missing toolCallId — an in-flight part that could never be closed`, () => {
+        expect(parseAgentPart({ id: 'p1', type: 'tool', ...UNIDENTIFIED_RAW[state] })).toBeNull()
+      })
+
+      test(`${state}: rejects an empty-string toolCallId identically (it means absent)`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: '', ...UNIDENTIFIED_RAW[state] }
+        expect(parseAgentPart(raw)).toBeNull()
+      })
+    }
+
+    for (const state of SETTLED_STATES) {
+      test(`${state}: a missing toolCallId keeps the part UNIDENTIFIED — it is never dropped`, () => {
+        const parsed = parseAgentPart({ id: 'p1', type: 'tool', ...UNIDENTIFIED_RAW[state] })
+        expect(parsed).not.toBeNull()
+        expect((parsed as ToolCallPart).state).toBe(state)
+        expect(Object.hasOwn(parsed as object, 'toolCallId')).toBe(false)
+      })
+
+      test(`${state}: an empty-string toolCallId normalizes to absent, never to ""`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: '', ...UNIDENTIFIED_RAW[state] }
+        const parsed = parseAgentPart(raw)
+        expect(parsed).not.toBeNull()
+        expect(Object.hasOwn(parsed as object, 'toolCallId')).toBe(false)
+      })
+
+      test(`${state}: a real toolCallId still carries through`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: 'call-1', ...UNIDENTIFIED_RAW[state] }
+        expect((parseAgentPart(raw) as ToolCallPart | null)?.toolCallId).toBe('call-1')
+      })
+    }
+
+    test('approval-responded: a real toolCallId round-trips through JSON', () => {
+      const part: ToolCallPart = {
+        id: 'p1',
+        type: 'tool',
+        toolCallId: 'call-1',
+        toolName: 'delete_file',
+        state: 'approval-responded',
+        input: { path: '/tmp/x' },
+        approval: { id: 'appr-1', approved: true },
+      }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+
     test('rejects a missing toolName', () => {
       const raw = {
         id: 'p1',

package/src/agent/parts.ts

@@ -3,7 +3,10 @@
  *
  * Exhaustiveness is enforced at every switch via assertNever (imported from '../register').
  * Adding a new variant without a matching case is a tsc error — see the fixture in
- * apps/playground/src/demo/agent-part.type-guard.ts.
+ * apps/playground/src/demo/agent-part.type-guard.ts. One caveat for code that folds WIRE data on
+ * the render path (`coalesceParts`): keep the compile-time guarantee — bind the value at `never` —
+ * but do NOT let the runtime throw, or one malformed chunk kills the whole transcript. See
+ * `mergeToolPart`'s default branch for that shape.
  *
  * Eden #231 doctrine: the server-side Elysia route MUST declare `: AsyncGenerator<AgentPart>`
  * explicitly and carry NO t.Object/t.Union response schema. Validate at yield-time. See
@@ -78,6 +81,10 @@ export type ReasoningPart = PartBase & {
 // discriminator `tool-${NAME}`. It IS a required field here (ours, not the SDK's) because the chip
 // needs it; a transport mapping from the SDK must DERIVE it from the discriminator, not read it off
 // the invocation.
+//
+// `toolCallId` is required on the three IN-FLIGHT states and OPTIONAL on the four SETTLED ones —
+// see `Identified` / `MaybeIdentified` below. The absence is modelled in the type, never as a
+// sentinel value.
 
 /** The nested approval envelope — mirrors the SDK's shape verbatim, never flattened. */
 type ToolApproval = {
@@ -90,35 +97,66 @@ type ToolApproval = {
 
 type ToolCallBase = PartBase & {
   readonly type: 'tool'
-  /** Required on all seven states (was optional — see parts.ts history). */
-  readonly toolCallId: string
   readonly toolName: string
   /** Wall-clock time from first sighting of this toolCallId to its terminal state. */
   readonly durationMs?: number
   readonly providerExecuted?: boolean
 }
 
+/**
+ * The three IN-FLIGHT states (`input-streaming`, `input-available`, `approval-requested`) carry an
+ * authoritative `toolCallId` — the merge key, and for them it is structural. An in-flight part
+ * exists only to be superseded by the settled part for the same call; with no merge key it can
+ * never be closed, so it would render as a forever-pending chip standing beside the real result.
+ * Nothing is lost by rejecting an unidentified one either: the `toolName` and `input` it carries
+ * are re-supplied on the settled part. `parseToolCallPart` therefore rejects these when the id is
+ * missing or empty.
+ */
+type Identified = ToolCallBase & { readonly toolCallId: string }
+
+/**
+ * The four SETTLED states (`approval-responded` plus the three terminal ones) may legitimately
+ * arrive without a `toolCallId`, for two different reasons.
+ *
+ * `approval-responded` is where the WIRE omits it: the SDK's `tool-approval-response` chunk
+ * carries none, and it is resolved by reverse lookup on `approval.id` (coalesce.ts keeps the
+ * approvalId -> toolCallId side index that does it).
+ *
+ * The three terminal states admit the absence for a different reason — tolerance, not wire shape.
+ * They are self-contained: each carries the OUTCOME of the call, so a missing id costs only the
+ * fold (`coalesceParts` keeps an unresolvable part as its own block and never discards it).
+ * Rejecting one instead would delete the only record of how the call ended — silent data loss in a
+ * transcript, strictly worse than an unfolded block.
+ *
+ * The absence is modelled here rather than smuggled through an empty-string sentinel: the union
+ * previously declared an always-meaningful `string` that the `approval-responded` wire shape
+ * cannot supply, which forced a `''` sentinel into the type and an `as unknown as` cast into every
+ * test that built one. A `''` toolCallId is not a value any state accepts; `parseToolCallPart`
+ * normalizes one to absent at the wire boundary, so it never reaches the type or a consumer.
+ */
+type MaybeIdentified = ToolCallBase & { readonly toolCallId?: string }
+
 export type ToolCallPart =
-  | (ToolCallBase & { readonly state: 'input-streaming'; readonly input?: unknown })
-  | (ToolCallBase & { readonly state: 'input-available'; readonly input: unknown })
-  | (ToolCallBase & {
+  | (Identified & { readonly state: 'input-streaming'; readonly input?: unknown })
+  | (Identified & { readonly state: 'input-available'; readonly input: unknown })
+  | (Identified & {
       readonly state: 'approval-requested'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved?: never; readonly reason?: never }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'approval-responded'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved: boolean }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-available'
       readonly input: unknown
       readonly output: unknown
       readonly preliminary?: boolean
       readonly approval?: ToolApproval & { readonly approved?: true }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-error'
       readonly input?: unknown
       /** The SDK's field name — there is no field named `error` anywhere in the union. */
@@ -127,7 +165,7 @@ export type ToolCallPart =
       readonly rawInput?: unknown
       readonly approval?: ToolApproval & { readonly approved?: true }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-denied'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved: false }
@@ -236,35 +274,53 @@ export function parseAgentPart(raw: unknown): AgentPart | null {
 }
 
 /** Validates the state-discriminated `tool` part shape. Rejects the pre-1.11.0 flat shape
- * (`{type:'tool', output}` with no `state`) and any unrecognized `state` value. */
+ * (`{type:'tool', output}` with no `state`) and any unrecognized `state` value.
+ *
+ * An empty-string `toolCallId` is normalized to absent here — the one place the wire's degenerate
+ * shape is decoded — so `''` never reaches the type or any consumer of it. What an ABSENT id then
+ * means is decided per state, exactly as the union declares it (`Identified` /
+ * `MaybeIdentified`): fatal on the three in-flight states, which exist only to be closed by a
+ * later one and are re-supplied by it; survivable on the four settled states, which carry the
+ * outcome and are kept UNIDENTIFIED rather than dropped. Dropping a settled part would be silent
+ * data loss — the transcript would simply forget how the call ended. */
 function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPart | null {
-  if (typeof obj['toolCallId'] !== 'string') return null
   if (typeof obj['toolName'] !== 'string') return null
   if (typeof obj['state'] !== 'string') return null
 
-  const { toolCallId, toolName } = obj as { toolCallId: string; toolName: string }
+  const rawToolCallId = obj['toolCallId']
+  if (rawToolCallId !== undefined && typeof rawToolCallId !== 'string') return null
+  const toolCallId =
+    typeof rawToolCallId === 'string' && rawToolCallId.length > 0 ? rawToolCallId : undefined
+
+  const toolName = obj['toolName']
   const common = {
     id,
     type: 'tool' as const,
-    toolCallId,
     toolName,
     ...(typeof obj['durationMs'] === 'number' ? { durationMs: obj['durationMs'] } : {}),
     ...(typeof obj['providerExecuted'] === 'boolean'
       ? { providerExecuted: obj['providerExecuted'] }
       : {}),
   }
+  // The three in-flight states below require an identified call; the four settled ones spread
+  // `identity` instead, which is simply empty when the wire supplied no usable id.
+  const identified = toolCallId !== undefined ? { ...common, toolCallId } : null
+  const identity = toolCallId !== undefined ? { toolCallId } : {}
 
   switch (obj['state']) {
     case 'input-streaming':
+      if (identified === null) return null
       return {
-        ...common,
+        ...identified,
         state: 'input-streaming',
         ...('input' in obj ? { input: obj['input'] } : {}),
       }
     case 'input-available':
+      if (identified === null) return null
       if (!('input' in obj)) return null
-      return { ...common, state: 'input-available', input: obj['input'] }
+      return { ...identified, state: 'input-available', input: obj['input'] }
     case 'approval-requested': {
+      if (identified === null) return null
       if (!('input' in obj)) return null
       const approval = parseApproval(obj['approval'])
       // The type declares this state's approval as `{ approved?: never; reason?: never }` — a
@@ -274,7 +330,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
         return null
       }
       return {
-        ...common,
+        ...identified,
         state: 'approval-requested',
         input: obj['input'],
         approval: approval as ToolApproval & { approved?: never; reason?: never },
@@ -284,8 +340,10 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       if (!('input' in obj)) return null
       const approval = parseApproval(obj['approval'])
       if (approval === null || typeof approval.approved !== 'boolean') return null
+      // The state the WIRE ships unidentified — `approval.id` is then its only addressing key.
       return {
         ...common,
+        ...identity,
         state: 'approval-responded',
         input: obj['input'],
         approval: approval as ToolApproval & { approved: boolean },
@@ -297,6 +355,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       if (approval === null || approval.approved !== false) return null
       return {
         ...common,
+        ...identity,
         state: 'output-denied',
         input: obj['input'],
         approval: approval as ToolApproval & { approved: false },
@@ -315,6 +374,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       }
       return {
         ...common,
+        ...identity,
         state: 'output-available',
         input: obj['input'],
         output: obj['output'],
@@ -332,6 +392,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       }
       return {
         ...common,
+        ...identity,
         state: 'output-error',
         errorText: obj['errorText'],
         ...('input' in obj ? { input: obj['input'] } : {}),

package/src/agent/thread.test.ts

@@ -1,6 +1,7 @@
 /**
  * createThreadsStore — ring-buffer caps (maxThreads/maxMessagesPerThread), newest-first ordering,
- * setResumeToken's delete-the-key-on-undefined semantics, and same-tick action accumulation.
+ * setResumeToken's delete-the-key-on-undefined semantics, same-tick action accumulation, and the
+ * constant hydrated/error pair the async sibling store (./adapter) actually varies.
  *
  * Uses the REAL localStorage-backed store (happy-dom provides `window.localStorage`), so every
  * test uses its own unique `key` — the same convention as
@@ -13,7 +14,12 @@ 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() }
+  return {
+    id,
+    role: 'user',
+    parts: [{ id: `${id}-p0`, type: 'text', text: id }],
+    createdAt: Date.now(),
+  }
 }
 
 describe('createThreadsStore', () => {
@@ -144,4 +150,71 @@ describe('createThreadsStore', () => {
     expect(thread?.status).toBe('streaming')
     expect(thread?.resumeToken).toBe('tok-accum')
   })
+
+  test('hydrated is always true and error always undefined — localStorage resolves synchronously', () => {
+    const useThreads = createThreadsStore({ key: 'thread-hydrated-a', version: 1 })
+    const { result } = renderHook(() => useThreads())
+
+    // Pinned because these two exist for the async adapter store (./adapter); the localStorage
+    // store must fill them with the "nothing to wait for, nothing to report" constants on the
+    // very first render, before any action has run.
+    expect(result.current.hydrated).toBe(true)
+    expect(result.current.error).toBeUndefined()
+
+    act(() => {
+      result.current.create()
+    })
+
+    expect(result.current.hydrated).toBe(true)
+    expect(result.current.error).toBeUndefined()
+  })
+
+  test('create() mints distinct ids via crypto.getRandomValues when randomUUID is unavailable', () => {
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', {
+      value: { getRandomValues: originalCrypto.getRandomValues.bind(originalCrypto) },
+      configurable: true,
+    })
+    try {
+      const useThreads = createThreadsStore({ key: 'thread-crypto-a', version: 1 })
+      const { result } = renderHook(() => useThreads())
+
+      let first = ''
+      let second = ''
+      act(() => {
+        first = result.current.create()
+        second = result.current.create()
+      })
+
+      expect(first).not.toBe('')
+      expect(second).not.toBe('')
+      expect(first).not.toBe(second)
+    } finally {
+      // Restore the real crypto so no later test in the process is affected.
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+  })
+
+  test('create() still mints distinct ids with no usable crypto at all (randomUUID and getRandomValues both absent)', () => {
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', { value: undefined, configurable: true })
+    try {
+      const useThreads = createThreadsStore({ key: 'thread-crypto-b', version: 1 })
+      const { result } = renderHook(() => useThreads())
+
+      let first = ''
+      let second = ''
+      act(() => {
+        first = result.current.create()
+        second = result.current.create()
+      })
+
+      expect(first).not.toBe('')
+      expect(second).not.toBe('')
+      expect(first).not.toBe(second)
+    } finally {
+      // Restore the real crypto so no later test in the process is affected.
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+  })
 })

package/src/agent/thread.ts

@@ -24,6 +24,7 @@
 import { useCallback, useRef } from 'react'
 import { createPersistedState } from '../state'
 import type { ChatMessage } from './history'
+import { mintThreadId } from './id'
 import type { AgentOutcome } from './outcome'
 import type { AgentPart } from './parts'
 
@@ -138,6 +139,20 @@ export type ThreadsStore<TPart = AgentPart> = {
   readonly remove: (id: string) => void
   /** Remove all threads and clear the active selection. */
   readonly clear: () => void
+  /**
+   * Whether `threads` reflects the backing store yet. Always `true` for the localStorage store
+   * (createPersistedState resolves synchronously); meaningful only for an async, server-backed
+   * store built with `createAdapterThreadsStore` (./adapter), where it stays `false` until the
+   * first `listThreads` SUCCEEDS. Pair it with `error` — `!hydrated && error !== undefined` is a
+   * failed load, `!hydrated && error === undefined` is still loading.
+   */
+  readonly hydrated: boolean
+  /**
+   * The most recent persistence failure, or `undefined`. Always `undefined` for the localStorage
+   * store, which has no failure the caller can act on. An async store surfaces the rejected
+   * load/write here after rolling its optimistic edit back.
+   */
+  readonly error: unknown
 }
 
 // ── createThreadsStore ────────────────────────────────────────────────────────
@@ -198,7 +213,7 @@ export function createThreadsStore<TPart = AgentPart>(
 
     const create = useCallback(
       (createOpts?: { readonly meta?: Record<string, unknown> }): string => {
-        const id = crypto.randomUUID()
+        const id = mintThreadId()
         const now = Date.now()
         const thread: AgentThread<TPart> = {
           id,
@@ -307,6 +322,11 @@ export function createThreadsStore<TPart = AgentPart>(
       markRead,
       remove,
       clear,
+      // localStorage resolves synchronously and swallows its own quota errors, so there is never
+      // a pending load to await nor a failure a caller could act on. See ./adapter for the async
+      // store where these two carry real information.
+      hydrated: true,
+      error: undefined,
     }
   }
 }

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

@@ -11,7 +11,7 @@ import { StrictMode, useEffect } from 'react'
 import { act, render, renderHook, waitFor } from '@testing-library/react'
 import { useAgentStream } from './use-agent-stream'
 import type { AgentTransport } from './transport'
-import type { AgentPart } from './parts'
+import type { AgentPart, AgentPartDraft } from './parts'
 
 function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
   let resolve!: (value: T) => void
@@ -96,17 +96,21 @@ describe('useAgentStream', () => {
   })
 
   test('F1 regression: id-less drafts of different types within one send() do not destroy each other', async () => {
+    // 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
       },
     }
 
@@ -131,7 +135,7 @@ describe('useAgentStream', () => {
       async *stream() {
         throw boom
         // eslint-disable-next-line no-unreachable
-        yield { type: 'text', text: 'unreachable' }
+        yield { id: 'unreachable', type: 'text', text: 'unreachable' }
       },
     }
 

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

@@ -86,6 +86,11 @@ function createTestThreadsStore(): ThreadsStore<TranscriptPart> {
       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,
   }
 }
 

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

@@ -16,7 +16,7 @@ import { describe, expect, test } from 'bun:test'
 import { 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 { AgentTransport, ResumableAgentTransport } from './transport'
 import type { AgentPart } from './parts'
 import type { ChatMessage } from './history'
 import type { AgentOutcome } from './outcome'
@@ -90,6 +90,11 @@ function createTestThreadsStore(initial: AgentThread<AgentPart>[]): ThreadsStore
       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,
   }
 }
 
@@ -100,7 +105,7 @@ function makeStreamingThread(
   const userMessage: ChatMessage<AgentPart> = {
     id: crypto.randomUUID(),
     role: 'user',
-    parts: [{ type: 'text', text: 'hello' }],
+    parts: [{ id: 'seed-user-part', type: 'text', text: 'hello' }],
     createdAt: now,
   }
   return {
@@ -142,7 +147,7 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const userMessage: ChatMessage<AgentPart> = {
       id: crypto.randomUUID(),
       role: 'user',
-      parts: [{ type: 'text', text: 'hello' }],
+      parts: [{ id: 'seed-user-part', type: 'text', text: 'hello' }],
       createdAt: now,
     }
     const thread: AgentThread<AgentPart> = {
@@ -157,11 +162,11 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const store = createTestThreadsStore([thread])
 
     let resumeCalls = 0
-    const transport = {
+    const transport: ResumableAgentTransport<AgentPart, string> = {
       async *stream() {},
       async *resume() {
         resumeCalls++
-        yield { type: 'text', text: 'resumed' }
+        yield { id: 'p1', type: 'text', text: 'resumed' }
       },
       idempotentReplay: true as const,
     }
@@ -179,11 +184,11 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const store = createTestThreadsStore([thread])
 
     let resumeCalls = 0
-    const transport = {
+    const transport: ResumableAgentTransport<AgentPart, string> = {
       async *stream() {},
       async *resume() {
         resumeCalls++
-        yield { type: 'text', text: 'resumed' }
+        yield { id: 'p1', type: 'text', text: 'resumed' }
       },
       idempotentReplay: true as const,
     }
@@ -205,7 +210,7 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
       async *stream() {},
       async *resume() {
         resumeCalls++
-        yield { type: 'text', text: 'resumed' }
+        yield { id: 'p1', type: 'text', text: 'resumed' }
       },
       // deliberately NO idempotentReplay: true
     }
@@ -223,11 +228,11 @@ describe('useAgentThreadRuns — mount-time reconcile', () => {
     const store = createTestThreadsStore([thread])
 
     const resumeArgs: string[] = []
-    const transport = {
+    const transport: ResumableAgentTransport<AgentPart, string> = {
       async *stream() {},
-      async *resume(token: string) {
+      async *resume(token) {
         resumeArgs.push(token)
-        yield { type: 'text', text: 'resumed' }
+        yield { id: 'p1', type: 'text', text: 'resumed' }
       },
       idempotentReplay: true as const,
     }