basalt-ui 1.26.0 → 1.28.0

package/src/agent/thread.test.ts

@@ -1,220 +0,0 @@
-/**
- * createThreadsStore — ring-buffer caps (maxThreads/maxMessagesPerThread), newest-first ordering,
- * 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
- * `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: [{ id: `${id}-p0`, 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')
-  })
-
-  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/transport.test.ts

@@ -1,70 +0,0 @@
-/**
- * transport — `isResumable` and `edenTransport`'s opt-in `idempotentReplay` flag.
- *
- * `resume` alone is NOT enough for a transport to be treated as resumable: `isResumable` also
- * requires the literal `idempotentReplay: true` assertion, and `edenTransport` only sets it when
- * the caller opts in explicitly via a third argument — never inferred from `resumeCall` alone.
- */
-import { describe, expect, test } from 'bun:test'
-import { edenTransport, isResumable } from './transport'
-import type { AgentTransport } from './transport'
-import type { AgentPart } from './parts'
-
-describe('isResumable', () => {
-  test('false for a transport with no resume() at all', () => {
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream() {},
-    }
-    expect(isResumable(transport)).toBe(false)
-  })
-
-  test('false for a transport with resume() but WITHOUT idempotentReplay — resume alone is not enough', () => {
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream() {},
-      async *resume() {
-        yield { id: 'p1', type: 'text', text: 'resumed' }
-      },
-    }
-    expect(isResumable(transport)).toBe(false)
-  })
-
-  test('true only once BOTH resume() and idempotentReplay: true are present', () => {
-    const transport = {
-      async *stream() {},
-      async *resume() {
-        yield { id: 'p1', type: 'text', text: 'resumed' }
-      },
-      idempotentReplay: true as const,
-    }
-    expect(isResumable(transport)).toBe(true)
-  })
-})
-
-describe('edenTransport — idempotentReplay is opt-in, never inferred', () => {
-  test('no resumeCall at all → the returned object has NO resume key', () => {
-    const transport = edenTransport<AgentPart>(async () => ({
-      data: (async function* () {})(),
-      error: null,
-    }))
-    expect('resume' in transport).toBe(false)
-    expect(isResumable(transport)).toBe(false)
-  })
-
-  test('resumeCall supplied but NO options → resume() exists but isResumable is still false', () => {
-    const transport = edenTransport<AgentPart>(
-      async () => ({ data: (async function* () {})(), error: null }),
-      async () => ({ data: (async function* () {})(), error: null }),
-    )
-    expect(typeof transport.resume).toBe('function')
-    expect(isResumable(transport)).toBe(false)
-  })
-
-  test('resumeCall + { idempotentReplay: true } → isResumable is true', () => {
-    const transport = edenTransport<AgentPart>(
-      async () => ({ data: (async function* () {})(), error: null }),
-      async () => ({ data: (async function* () {})(), error: null }),
-      { idempotentReplay: true },
-    )
-    expect(isResumable(transport)).toBe(true)
-  })
-})

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

@@ -1,287 +0,0 @@
-/**
- * useAgentStream — single in-flight-turn lifecycle: abort, supersede, error, AbortError handling,
- * unmount cleanup, and StrictMode double-invoke of a "send on mount" consumer effect.
- *
- * Scope: the API AS IT EXISTS TODAY (B1) — no stop-preserves-the-partial-turn semantics, no
- * `ChatMessage.finish`; those are later-release surface (see the sibling `use-agent-thread-runs.*`
- * test files' scope note).
- */
-import { describe, expect, test } from 'bun:test'
-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, AgentPartDraft } from './parts'
-
-function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((r) => {
-    resolve = r
-  })
-  return { promise, resolve }
-}
-
-describe('useAgentStream', () => {
-  test('stop() mid-stream sets status "done" and discards any parts that arrive after the abort', async () => {
-    const gate = deferred<void>()
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream() {
-        yield { id: 'p1', type: 'text', text: 'a' }
-        await gate.promise
-        // Must never be observed — the consumer's guard should discard this once aborted.
-        yield { id: 'p2', type: 'text', text: 'b' }
-      },
-    }
-
-    const { result } = renderHook(() => useAgentStream({ transport }))
-
-    act(() => {
-      void result.current.send('hi')
-    })
-    await waitFor(() => {
-      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
-    })
-    expect(result.current.status).toBe('streaming')
-
-    act(() => {
-      result.current.stop()
-    })
-    // stop() sets 'done' synchronously — never 'error', even for an in-flight stream.
-    expect(result.current.status).toBe('done')
-
-    gate.resolve(undefined)
-    await waitFor(() => {
-      expect(result.current.status).toBe('done')
-    })
-    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 () => {
-    const gateFirst = deferred<void>()
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream(input) {
-        if (input === 'first') {
-          yield { id: 'f1', type: 'text', text: 'first-1' }
-          await gateFirst.promise
-          // Must never be observed — 'second' has already superseded this controller.
-          yield { id: 'f2', type: 'text', text: 'first-2' }
-        } else {
-          yield { id: 's1', type: 'text', text: 'second-1' }
-        }
-      },
-    }
-
-    const { result } = renderHook(() => useAgentStream({ transport }))
-
-    act(() => {
-      void result.current.send('first')
-    })
-    await waitFor(() => {
-      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([{ id: 's1', type: 'text', text: 'second-1' }])
-    })
-    expect(result.current.status).toBe('done')
-
-    gateFirst.resolve(undefined)
-    await waitFor(() => {
-      expect(result.current.status).toBe('done')
-    })
-    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 () => {
-    // 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' } as AgentPartDraft as AgentPart
-        yield {
-          type: 'tool',
-          toolCallId: 'c1',
-          toolName: 'search',
-          state: 'input-available',
-          input: { q: 'x' },
-        } as AgentPartDraft as AgentPart
-        yield { type: 'text', text: 'Bye' } as AgentPartDraft as AgentPart
-      },
-    }
-
-    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 () => {
-    const boom = new Error('boom')
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream() {
-        throw boom
-        // eslint-disable-next-line no-unreachable
-        yield { id: 'unreachable', type: 'text', text: 'unreachable' }
-      },
-    }
-
-    const { result } = renderHook(() => useAgentStream({ transport }))
-
-    await act(async () => {
-      await result.current.send('hi')
-    })
-
-    expect(result.current.status).toBe('error')
-    expect(result.current.error).toBe(boom)
-  })
-
-  test('an AbortError thrown by the transport is ignored — it never overwrites status with "error"', async () => {
-    const gate = deferred<void>()
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream(_input, signal) {
-        yield { id: 'p1', type: 'text', text: 'a' }
-        await gate.promise
-        if (signal?.aborted) throw new DOMException('The operation was aborted.', 'AbortError')
-        yield { id: 'p2', type: 'text', text: 'b' }
-      },
-    }
-
-    const { result } = renderHook(() => useAgentStream({ transport }))
-
-    act(() => {
-      void result.current.send('hi')
-    })
-    await waitFor(() => {
-      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
-    })
-
-    // stop() aborts the signal AND sets 'done' synchronously.
-    act(() => {
-      result.current.stop()
-    })
-    expect(result.current.status).toBe('done')
-
-    // The transport now throws AbortError (asynchronously, after 'done' is already set) — this
-    // must be swallowed by the catch's `err.name === 'AbortError'` guard, never flip to 'error'.
-    gate.resolve(undefined)
-    await waitFor(() => {
-      expect(result.current.status).toBe('done')
-    })
-    expect(result.current.error).toBeUndefined()
-  })
-
-  test('unmount aborts the in-flight stream', async () => {
-    let observedAbortedOnResume = false
-    const gate = deferred<void>()
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream(_input, signal) {
-        yield { id: 'p1', type: 'text', text: 'a' }
-        await gate.promise
-        observedAbortedOnResume = signal?.aborted ?? false
-      },
-    }
-
-    const { result, unmount } = renderHook(() => useAgentStream({ transport }))
-
-    act(() => {
-      void result.current.send('hi')
-    })
-    await waitFor(() => {
-      expect(result.current.parts).toEqual([{ id: 'p1', type: 'text', text: 'a' }])
-    })
-
-    unmount()
-
-    gate.resolve(undefined)
-    // Let the generator's resumed step run and observe the signal.
-    await new Promise((resolveTick) => setTimeout(resolveTick, 0))
-    expect(observedAbortedOnResume).toBe(true)
-  })
-
-  test('StrictMode double-invoke of a "send on mount" consumer effect: the surviving stream is the only one reflected in final state', async () => {
-    // useAgentStream itself never calls transport.stream() from an effect — only send() does, and
-    // send() is consumer-invoked. The realistic StrictMode hazard is therefore a consumer's own
-    // `useEffect(() => { void send(x) }, [])` "send the first turn on mount" pattern, which
-    // StrictMode's dev-only double-invoke runs twice against the SAME fiber. Verified empirically
-    // (reported alongside this suite): transport.stream() IS called twice in that scenario — the
-    // first pass's controller is aborted (both by useAgentStream's own unmount-cleanup effect
-    // during the simulated unmount, and redundantly by send()'s own
-    // `controllerRef.current?.abort()` at the top of the second call) — so exactly ONE stream's
-    // output is ever reflected in the hook's observable state, even though the transport function
-    // itself was invoked twice. That is the invariant this test pins, not a literal single
-    // `transport.stream()` call count.
-    let streamCalls = 0
-    let capturedParts: AgentPart[] = []
-    let capturedStatus = ''
-
-    const transport: AgentTransport<AgentPart, string> = {
-      async *stream() {
-        streamCalls++
-        yield { id: `call-${streamCalls}`, type: 'text', text: `call-${streamCalls}` }
-      },
-    }
-
-    function Consumer(): null {
-      const { send, parts, status } = useAgentStream({ transport })
-      capturedParts = parts
-      capturedStatus = status
-      useEffect(() => {
-        void send('initial')
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-      }, [])
-      return null
-    }
-
-    await act(async () => {
-      render(
-        <StrictMode>
-          <Consumer />
-        </StrictMode>,
-      )
-    })
-
-    await waitFor(() => {
-      expect(capturedStatus).toBe('done')
-    })
-
-    expect(streamCalls).toBe(2)
-    // 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 })
-    }
-  })
-})