basalt-ui 1.27.0 → 1.28.0

package/src/agent/merge.test.ts

@@ -1,206 +0,0 @@
-/**
- * mergePart — the identity-addressed accumulator. The behaviour under test that matters most:
- * replaying a whole run from character offset 0 rebuilds the identical parts array it produced
- * the first time — it cannot double the content.
- */
-import { describe, expect, test } from 'bun:test'
-import { mergePart } from './merge'
-import type { TranscriptPart } from './foreign'
-import type { AgentPart, TextPart, ToolCallPart } from './parts'
-
-describe('mergePart', () => {
-  test('appends a part whose id is not yet present', () => {
-    const parts: AgentPart[] = [{ id: 'p1', type: 'text', text: 'Hi' }]
-    const next: AgentPart = { id: 'p2', type: 'text', text: 'there' }
-    expect(mergePart(parts, next)).toEqual([
-      { id: 'p1', type: 'text', text: 'Hi' },
-      { id: 'p2', type: 'text', text: 'there' },
-    ])
-  })
-
-  test('an undefined offset splices at the tail (append)', () => {
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hel' }]
-    const next: TextPart = { id: 'p1', type: 'text', text: 'lo' }
-    const [merged] = mergePart(parts, next)
-    expect(merged?.text).toBe('Hello')
-  })
-
-  test('splices an explicit offset into the middle of the existing text', () => {
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hello world' }]
-    // Replace the 5-char span starting at offset 6 ("world") with "there"
-    const next: TextPart = { id: 'p1', type: 'text', text: 'there', offset: 6 }
-    const [merged] = mergePart(parts, next)
-    expect(merged?.text).toBe('Hello there')
-  })
-
-  test('reasoning splices the same way as text', () => {
-    const parts = [{ id: 'p1', type: 'reasoning' as const, text: 'thinking' }]
-    const next = { id: 'p1', type: 'reasoning' as const, text: ' more' }
-    const [merged] = mergePart(parts, next)
-    expect(merged?.text).toBe('thinking more')
-  })
-
-  test('offset-0 full replay rebuilds an identical array — it does not double the content', () => {
-    // First pass: two deltas building "Hello world" from nothing.
-    let parts: TextPart[] = []
-    parts = mergePart(parts, { id: 'p1', type: 'text', text: 'Hello' })
-    parts = mergePart(parts, { id: 'p1', type: 'text', text: ' world', offset: 5 })
-    expect(parts).toHaveLength(1)
-    expect(parts[0]?.text).toBe('Hello world')
-    const firstPassResult = parts
-
-    // Replay from character 0: the whole run resent as one delta at offset 0.
-    const replayed = mergePart(parts, { id: 'p1', type: 'text', text: 'Hello world', offset: 0 })
-
-    expect(replayed).toHaveLength(1)
-    expect(replayed[0]?.text).toBe('Hello world')
-    expect(replayed).toEqual(firstPassResult.map((p) => ({ ...p, offset: 0 })))
-  })
-
-  // ── out-of-range offsets ───────────────────────────────────────────────────
-  // spliceText supports exactly two shapes (append at the end, in-range replace). Everything else
-  // is CLAMPED into [0, existing.text.length] with a dev warning — never thrown on, because a
-  // throw on the render path turns a transient wire anomaly into a permanently dead transcript.
-
-  test('an offset past the end of the existing text clamps to the tail (appends, leaves no hole)', () => {
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hi' }]
-    const [merged] = mergePart(parts, { id: 'p1', type: 'text', text: '!', offset: 10 })
-    expect(merged?.text).toBe('Hi!')
-  })
-
-  test('a negative offset clamps to 0 rather than slicing from the end', () => {
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hello world' }]
-    const [merged] = mergePart(parts, { id: 'p1', type: 'text', text: 'Hey', offset: -3 })
-    expect(merged?.text).toBe('Heylo world')
-  })
-
-  test('an out-of-order (already-covered) offset replaces in place — it never re-appends', () => {
-    // 'Hello world' is fully accumulated; a straggler delta for offset 6 arrives after the tail
-    // has moved past it. In-range, so it is honoured as a replace, not clamped.
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hello world' }]
-    const [merged] = mergePart(parts, { id: 'p1', type: 'text', text: 'WORLD', offset: 6 })
-    expect(merged?.text).toBe('Hello WORLD')
-  })
-
-  test('a non-finite offset clamps to the tail rather than blanking the part', () => {
-    const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hi' }]
-    const [merged] = mergePart(parts, { id: 'p1', type: 'text', text: '!', offset: Number.NaN })
-    expect(merged?.text).toBe('Hi!')
-  })
-
-  test('a FIRST insertion with a nonzero offset clamps and warns like any other out-of-range one', () => {
-    // A first insertion splices against an EMPTY existing text, so the offset is out of range
-    // [0, 0]: mergePart never invents the 2 missing characters, it stores what arrived — but the
-    // anomaly is announced, exactly as it is for an existing part. One contract, one code path.
-    const warnings: string[] = []
-    const original = console.warn
-    console.warn = (...args: unknown[]) => void warnings.push(String(args[0]))
-    let first: TextPart[]
-    try {
-      first = mergePart<TextPart>([], { id: 'p1', type: 'text', text: 'llo', offset: 2 })
-    } finally {
-      console.warn = original
-    }
-    expect(warnings).toHaveLength(1)
-    expect(warnings[0]).toContain('out of range [0, 0]')
-    expect(first).toEqual([{ id: 'p1', type: 'text', text: 'llo', offset: 2 }])
-
-    // The offset rides along inert; the next delta for this id splices relative to the STORED text.
-    const [merged] = mergePart(first, { id: 'p1', type: 'text', text: ' there' })
-    expect(merged?.text).toBe('llo there')
-  })
-
-  test('a FIRST insertion with an in-range (0 or undefined) offset stays silent and stores the text as-is', () => {
-    const warnings: string[] = []
-    const original = console.warn
-    console.warn = (...args: unknown[]) => void warnings.push(String(args[0]))
-    try {
-      expect(mergePart<TextPart>([], { id: 'p1', type: 'text', text: 'Hello', offset: 0 })).toEqual(
-        [{ id: 'p1', type: 'text', text: 'Hello', offset: 0 }],
-      )
-      expect(mergePart<TextPart>([], { id: 'p2', type: 'text', text: 'Hello' })).toEqual([
-        { id: 'p2', type: 'text', text: 'Hello' },
-      ])
-    } finally {
-      console.warn = original
-    }
-    expect(warnings).toHaveLength(0)
-  })
-
-  test('warns in dev on an out-of-range offset, and stays silent on an in-range one', () => {
-    const warnings: string[] = []
-    const original = console.warn
-    console.warn = (...args: unknown[]) => void warnings.push(String(args[0]))
-    try {
-      const parts: TextPart[] = [{ id: 'p1', type: 'text', text: 'Hi' }]
-      mergePart(parts, { id: 'p1', type: 'text', text: '!', offset: 1 })
-      expect(warnings).toHaveLength(0)
-
-      mergePart(parts, { id: 'p1', type: 'text', text: '!', offset: 10 })
-      expect(warnings).toHaveLength(1)
-      expect(warnings[0]).toContain('out of range')
-    } finally {
-      console.warn = original
-    }
-  })
-
-  test('non-text/reasoning variants replace wholesale rather than merging fields', () => {
-    const parts: ToolCallPart[] = [
-      {
-        id: 'p1',
-        type: 'tool',
-        toolCallId: 'call-1',
-        toolName: 'search',
-        state: 'input-available',
-        input: { q: 'x' },
-      },
-    ]
-    const next: ToolCallPart = {
-      id: 'p1',
-      type: 'tool',
-      toolCallId: 'call-1',
-      toolName: 'search',
-      state: 'output-available',
-      input: { q: 'x' },
-      output: { hits: 3 },
-    }
-    expect(mergePart(parts, next)).toEqual([next])
-  })
-
-  test('a rewrite keeps the original position — ordering is stable', () => {
-    const parts: AgentPart[] = [
-      { id: 'a', type: 'text', text: 'first' },
-      { id: 'b', type: 'text', text: 'second' },
-      { id: 'c', type: 'text', text: 'third' },
-    ]
-    const next: AgentPart = { id: 'b', type: 'text', text: '!!', offset: 6 }
-    const merged = mergePart(parts, next)
-    expect(merged.map((p) => p.id)).toEqual(['a', 'b', 'c'])
-    expect((merged[1] as TextPart).text).toBe('second!!')
-  })
-
-  // B2 convergence fix: mergePart is constrained on PartLike (structural `id` + `type`), not the
-  // closed AgentPart union, precisely so a ForeignPart (never text-like) flows through the same
-  // accumulator. This is the compile-time contract `useAgentThreadRuns<TranscriptPart>` depends on.
-  test('a foreign part (never text-like) survives a round trip unchanged', () => {
-    const parts: TranscriptPart[] = []
-    const first = mergePart(parts, {
-      id: 'f1',
-      type: 'data-toolProgress',
-      tool: 'search',
-      message: 'searching',
-    })
-    expect(first).toEqual([
-      { id: 'f1', type: 'data-toolProgress', tool: 'search', message: 'searching' },
-    ])
-  })
-
-  test('a replayed foreign part (same id) replaces wholesale rather than duplicating', () => {
-    let parts: TranscriptPart[] = []
-    parts = mergePart(parts, { id: 'f1', type: 'data-toolProgress', message: 'searching' })
-    parts = mergePart(parts, { id: 'f1', type: 'data-toolProgress', message: 'done' })
-
-    expect(parts).toHaveLength(1)
-    expect(parts).toEqual([{ id: 'f1', type: 'data-toolProgress', message: 'done' }])
-  })
-})

package/src/agent/part-list.test.tsx

@@ -1,112 +0,0 @@
-/**
- * PartList's headless default tool-call renderer — a failed/denied call must stay visible.
- *
- * Regression coverage: after the seven-state ToolCallPart split, `output-error` carries no
- * `output` field, so the old `part.state === 'output-available'`-only body left a failed call
- * rendering as name+input and nothing else — the failure was silently invisible. Same gap for
- * `output-denied`, indistinguishable from a still-pending call.
- *
- * Plus the `settled` flag's forwarding contract — the field that lets a text renderer drop out of
- * streaming mode once the message it belongs to has finished.
- */
-import { cleanup, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, test } from 'bun:test'
-import { PartList } from './part-list'
-import type { AgentPart, ToolCallPart } from './parts'
-
-afterEach(cleanup)
-
-const BASE = { id: 'p1', type: 'tool' as const, toolCallId: 'c1', toolName: 'search' }
-
-describe('DefaultToolCall — terminal states stay visible', () => {
-  test('output-error renders the errorText', () => {
-    const part: ToolCallPart = { ...BASE, state: 'output-error', errorText: 'boom' }
-    render(<PartList parts={[part]} />)
-    expect(screen.getByText('boom')).not.toBeNull()
-  })
-
-  test('output-error with no validated input falls back to rendering rawInput', () => {
-    const part: ToolCallPart = {
-      ...BASE,
-      state: 'output-error',
-      errorText: 'boom',
-      rawInput: { q: 'x' },
-    }
-    render(<PartList parts={[part]} />)
-    expect(screen.getByText(/"q": "x"/)).not.toBeNull()
-  })
-
-  test('output-error with validated input present does not also render rawInput', () => {
-    const part: ToolCallPart = {
-      ...BASE,
-      state: 'output-error',
-      errorText: 'boom',
-      input: { q: 'x' },
-      rawInput: { q: 'stale' },
-    }
-    render(<PartList parts={[part]} />)
-    expect(screen.queryByText(/stale/)).toBeNull()
-  })
-
-  test('output-denied is visibly denied, not indistinguishable from a pending call', () => {
-    const part: ToolCallPart = {
-      ...BASE,
-      state: 'output-denied',
-      input: { q: 'x' },
-      approval: { id: 'a1', approved: false, reason: 'too risky' },
-    }
-    render(<PartList parts={[part]} />)
-    expect(screen.getByText(/Denied/)).not.toBeNull()
-    expect(screen.getByText(/too risky/)).not.toBeNull()
-  })
-
-  test('output-denied with no reason still renders a visible denial', () => {
-    const part: ToolCallPart = {
-      ...BASE,
-      state: 'output-denied',
-      input: { q: 'x' },
-      approval: { id: 'a1', approved: false },
-    }
-    render(<PartList parts={[part]} />)
-    expect(screen.getByText('Denied')).not.toBeNull()
-  })
-
-  test('output-available is unaffected — still renders output, no error/denied line', () => {
-    const part: ToolCallPart = {
-      ...BASE,
-      state: 'output-available',
-      input: { q: 'x' },
-      output: { hits: 3 },
-    }
-    render(<PartList parts={[part]} />)
-    expect(screen.getByText(/"hits": 3/)).not.toBeNull()
-    expect(screen.queryByText(/Denied/)).toBeNull()
-  })
-})
-
-describe('settled — forwarded to every renderer', () => {
-  const TEXT: AgentPart = { id: 't1', type: 'text', text: 'hello' }
-
-  function settledProbe() {
-    const seen: boolean[] = []
-    const components = {
-      text: ({ settled }: { settled: boolean }) => {
-        seen.push(settled)
-        return <div data-testid="probe">{String(settled)}</div>
-      },
-    }
-    return { seen, components }
-  }
-
-  test('defaults to true — a caller that knows nothing about a run renders a finished list', () => {
-    const { seen, components } = settledProbe()
-    render(<PartList parts={[TEXT]} components={components} />)
-    expect(seen).toEqual([true])
-  })
-
-  test('an explicit settled={false} reaches the renderer', () => {
-    const { seen, components } = settledProbe()
-    render(<PartList parts={[TEXT]} components={components} settled={false} />)
-    expect(seen).toEqual([false])
-  })
-})