basalt-ui 1.11.0 → 1.13.0

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,24 @@ 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.
+   *
+   * Gating an empty state on this is the CALLER's job when hand-assembling `ThreadFeed` /
+   * `ThreadDetailPanel`; the shipped `ThreadWorkspace` already does it internally, so an
+   * async store never flashes "no threads yet" through it before it actually knows.
+   */
+  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 +217,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 +326,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' }
       },
     }
 
@@ -258,4 +262,26 @@ describe('useAgentStream', () => {
     // Only the SECOND (surviving) call's part made it into final state — the first is discarded.
     expect(capturedParts).toEqual([{ id: 'call-2', type: 'text', text: 'call-2' }])
   })
+
+  test('send() still streams without throwing on a host with no usable crypto at all — its runId is a low-collision-cost mint (mintThreadId), never the message-id one', async () => {
+    const originalCrypto = globalThis.crypto
+    Object.defineProperty(globalThis, 'crypto', { value: undefined, configurable: true })
+    try {
+      const transport: AgentTransport<AgentPart, string> = {
+        async *stream() {
+          yield { type: 'text', text: 'a' } as AgentPartDraft as AgentPart
+        },
+      }
+      const { result } = renderHook(() => useAgentStream({ transport }))
+
+      await act(async () => {
+        await result.current.send('hi')
+      })
+
+      expect(result.current.status).toBe('done')
+      expect(result.current.parts).toHaveLength(1)
+    } finally {
+      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true })
+    }
+  })
 })

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

@@ -27,7 +27,7 @@
  * }
  */
 import { useCallback, useEffect, useRef, useState } from 'react'
-import { withPartIds } from './id'
+import { mintThreadId, withPartIds } from './id'
 import { isStartPart } from './parts'
 import { mergePart } from './merge'
 import type { PartLike } from './merge'
@@ -107,8 +107,11 @@ export function useAgentStream<TPart extends PartLike = AgentPart, TInput = stri
       // 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()
+      // resume() path — see withPartIds' own doc for why it can't be one anyway. Low collision
+      // cost (this hook persists nothing — `parts` is discarded on the next send()/unmount), so
+      // `mintThreadId` — never `mintMessageId` — is the right rung-3 behavior here: this must not
+      // throw on a host with no usable crypto at all.
+      const runId = mintThreadId()
 
       try {
         for await (const part of withPartIds(runId, transport.stream(input, controller.signal))) {

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,
     }