Skip to content

The agent that grows with you

24.8 KB
Raw Blame
import {
  AssistantRuntimeProvider,
  MessagePrimitive,
  type ThreadMessage,
  ThreadPrimitive,
  useExternalStoreRuntime
} from '@assistant-ui/react'
import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
import { useEffect, useState } from 'react'
import { beforeEach, describe, expect, it, vi } from 'vitest'

import { $onboardingPhase } from '@/store/onboarding-phase'
import { $onboardingSession } from '@/store/onboarding-session'
import { $reasoningCollapsedByDefault, setShowReasoningFromConfig } from '@/store/reasoning-disclosure'
import { $activeSessionId } from '@/store/session'

import { stubThreadEnvironment, stubThreadViewportSize, ThreadRuntime } from '../test-utils'

import { MESSAGE_PARTS_COMPONENTS } from './message-parts'

import { Thread } from '.'

const createdAt = new Date('2026-05-01T00:00:00.000Z')

const resizeObservers = new Set<TestResizeObserver>()

class TestResizeObserver {
  private target: Element | null = null

  constructor(private readonly callback: ResizeObserverCallback) {
    resizeObservers.add(this)
  }

  observe(target: Element) {
    this.target = target
  }

  unobserve() {}

  disconnect() {
    resizeObservers.delete(this)
  }

  triggerFor(target: Element, height: number) {
    if (this.target === target) {
      this.trigger(height)
    }
  }

  trigger(height: number) {
    if (!this.target) {
      return
    }

    this.callback(
      [
        {
          borderBoxSize: [{ blockSize: height, inlineSize: 800 }],
          contentRect: { height } as DOMRectReadOnly,
          target: this.target
        } as unknown as ResizeObserverEntry
      ],
      this as unknown as ResizeObserver
    )
  }
}

stubThreadEnvironment()

// This suite drives the virtualizer, so it needs an observer that reports.
vi.stubGlobal('ResizeObserver', TestResizeObserver)

stubThreadViewportSize()

async function wait(ms: number) {
  await act(async () => {
    await new Promise(resolve => window.setTimeout(resolve, ms))
  })
}

function userMessage(): ThreadMessage {
  return {
    id: 'user-1',
    role: 'user',
    content: [{ type: 'text', text: 'Stream a response' }],
    attachments: [],
    createdAt,
    metadata: { custom: {} }
  } as ThreadMessage
}

function assistantMessage(text: string, running = true): ThreadMessage {
  return {
    id: 'assistant-1',
    role: 'assistant',
    content: [{ type: 'text', text }],
    status: running ? { type: 'running' } : { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantErrorMessage(error: string): ThreadMessage {
  return {
    id: 'assistant-error-1',
    role: 'assistant',
    content: [],
    status: { type: 'incomplete', reason: 'error', error },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantReasoningMessage(text: string, running = false): ThreadMessage {
  return {
    id: 'assistant-reasoning-1',
    role: 'assistant',
    content: [{ type: 'reasoning', text }],
    status: running ? { type: 'running' } : { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantMultiReasoningMessage(texts: string[]): ThreadMessage {
  return {
    id: 'assistant-reasoning-multi-1',
    role: 'assistant',
    content: texts.map(text => ({ type: 'reasoning', text })),
    status: { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantSeparatedReasoningMessage(): ThreadMessage {
  return {
    id: 'assistant-reasoning-separated-1',
    role: 'assistant',
    content: [
      { type: 'reasoning', text: ' Complete first thought.', status: { type: 'complete' } },
      { type: 'text', text: 'Interim answer.' },
      { type: 'reasoning', text: ' Streaming second thought.', status: { type: 'running' } }
    ],
    status: { type: 'running' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantImageMessage(
  running = false,
  result: unknown = { image: 'https://cdn.example/cat.png', success: true }
): ThreadMessage {
  return {
    id: `assistant-image-${running ? 'running' : 'done'}`,
    role: 'assistant',
    content: [
      {
        type: 'tool-call',
        toolCallId: 'image-1',
        toolName: 'image_generate',
        args: { prompt: 'draw a cat' },
        argsText: JSON.stringify({ prompt: 'draw a cat' }),
        ...(running ? {} : { result })
      }
    ],
    status: running ? { type: 'running' } : { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

function assistantTerminalMessage(): ThreadMessage {
  return {
    id: 'assistant-terminal-1',
    role: 'assistant',
    content: [
      {
        type: 'tool-call',
        toolCallId: 'terminal-1',
        toolName: 'terminal',
        args: { command: 'npm run check --workspace=apps/desktop' },
        argsText: JSON.stringify({ command: 'npm run check --workspace=apps/desktop' }),
        result: { exit_code: 0, stdout: 'all checks passed' }
      }
    ],
    status: { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: {}
    }
  } as ThreadMessage
}

interface StreamingControls {
  emitSecond: () => void
  complete: () => void
}

function StreamingHarness({ onControls }: { onControls?: (controls: StreamingControls) => void } = {}) {
  const [messages, setMessages] = useState<ThreadMessage[]>([userMessage()])
  const [isRunning, setIsRunning] = useState(true)

  useEffect(() => {
    const first = window.setTimeout(() => {
      setMessages([userMessage(), assistantMessage('first chunk')])
    }, 50)

    if (onControls) {
      onControls({
        emitSecond: () => {
          setMessages([userMessage(), assistantMessage('first chunk second chunk')])
        },
        complete: () => {
          setMessages([userMessage(), assistantMessage('first chunk second chunk', false)])
          setIsRunning(false)
        }
      })

      return () => window.clearTimeout(first)
    }

    const second = window.setTimeout(() => {
      setMessages([userMessage(), assistantMessage('first chunk second chunk')])
    }, 500)

    const complete = window.setTimeout(() => {
      setMessages([userMessage(), assistantMessage('first chunk second chunk', false)])
      setIsRunning(false)
    }, 700)

    return () => {
      window.clearTimeout(first)
      window.clearTimeout(second)
      window.clearTimeout(complete)
    }
  }, [onControls])

  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages,
    isRunning,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread loading={isRunning && messages.at(-1)?.role !== 'assistant' ? 'response' : undefined} />
    </AssistantRuntimeProvider>
  )
}

function MessageHarness({ message }: { message: ThreadMessage }) {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [message],
    isRunning: false,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

function TranscriptHarness({ messages }: { messages: ThreadMessage[] }) {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages,
    isRunning: false,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

function assistantInterimMessage(text: string, id = 'assistant-interim-1'): ThreadMessage {
  return {
    id,
    role: 'assistant',
    content: [{ type: 'text', text }],
    status: { type: 'complete', reason: 'stop' },
    createdAt,
    metadata: {
      unstable_state: null,
      unstable_annotations: [],
      unstable_data: [],
      steps: [],
      custom: { interim: true }
    }
  } as ThreadMessage
}

function RunningMessageHarness({ message }: { message: ThreadMessage }) {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [message],
    isRunning: true,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

function ReasoningHarness() {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [assistantReasoningMessage(' The user is asking what this file is.')],
    isRunning: false,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

function RunningReasoningHarness() {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [assistantReasoningMessage('```ts\nconst answer = 42\n', true)],
    isRunning: true,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

// A turn that streams reasoning and then settles — the transition the
// preview latch exists for. `settle()` flips the thread to not-running.
function renderSettlingReasoning() {
  let setRunning: ((running: boolean) => void) | undefined

  function SettlingReasoningHarness() {
    const [running, setRunningState] = useState(true)

    setRunning = setRunningState

    const runtime = useExternalStoreRuntime<ThreadMessage>({
      messages: [assistantReasoningMessage('The user asked a question.', running)],
      isRunning: running,
      onNew: async () => {}
    })

    return (
      <AssistantRuntimeProvider runtime={runtime}>
        <Thread />
      </AssistantRuntimeProvider>
    )
  }

  const { container } = render(<SettlingReasoningHarness />)

  return { container, settle: () => act(() => setRunning?.(false)) }
}

function GroupedReasoningHarness() {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [assistantMultiReasoningMessage([' First thought.', ' Second thought.'])],
    isRunning: false,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread />
    </AssistantRuntimeProvider>
  )
}

function DismissibleErrorHarness({ onDismissError }: { onDismissError: (messageId: string) => void }) {
  const runtime = useExternalStoreRuntime<ThreadMessage>({
    messages: [assistantErrorMessage('OpenRouter rejected the request (403).')],
    isRunning: false,
    onNew: async () => {}
  })

  return (
    <AssistantRuntimeProvider runtime={runtime}>
      <Thread onDismissError={onDismissError} />
    </AssistantRuntimeProvider>
  )
}

describe('assistant-ui streaming renderer', () => {
  beforeEach(() => {
    resizeObservers.clear()
    $reasoningCollapsedByDefault.set(false)
    setShowReasoningFromConfig(undefined)
    $activeSessionId.set(null)
    $onboardingSession.set(null)
    $onboardingPhase.set('idle')
  })

  it.each([true, false])('honors reasoning visibility %j for grouped and standalone parts', async enabled => {
    setShowReasoningFromConfig(enabled)

    const UngroupedMessage = () => (
      <MessagePrimitive.Root>
        <MessagePrimitive.Parts components={{ Reasoning: MESSAGE_PARTS_COMPONENTS.Reasoning }} />
      </MessagePrimitive.Root>
    )

    const { container } = render(
      <>
        <RunningReasoningHarness />
        <ThreadRuntime messages={[assistantReasoningMessage('standalone reasoning', true)]}>
          <ThreadPrimitive.Root>
            <ThreadPrimitive.Messages components={{ AssistantMessage: UngroupedMessage, UserMessage: () => null }} />
          </ThreadPrimitive.Root>
        </ThreadRuntime>
      </>
    )

    await waitFor(() => {
      expect(container.querySelectorAll('[data-slot="aui_reasoning-text"]')).toHaveLength(enabled ? 2 : 0)
    })
    const thinking = within(container).queryByRole('button', { name: /thinking/i })
    const standalone = within(container).queryByText('standalone reasoning')

    if (enabled) {
      expect(thinking).not.toBeNull()
      expect(standalone).not.toBeNull()
    } else {
      expect(thinking).toBeNull()
      expect(standalone).toBeNull()
    }
  })

  it('renders assistant text incrementally before completion', async () => {
    let controls: StreamingControls | undefined

    const registerControls = (next: StreamingControls) => {
      controls = next
    }

    const { container } = render(<StreamingHarness onControls={registerControls} />)

    expect(screen.getByRole('status', { name: 'Hermes is loading a response' })).toBeTruthy()

    await waitFor(() => {
      expect(container.textContent).toContain('first chunk')
    })
    expect(container.textContent).not.toContain('second chunk')
    expect(screen.queryByRole('status', { name: 'Hermes is loading a response' })).toBeNull()

    // Producer-gated, not wall-clock-gated: the old test slept 80ms and
    // assumed a 500ms timer could not fire before the assertion. On a loaded
    // runner the test thread could be descheduled for >500ms, so both chunks
    // arrived and this clean behavior test flaked.
    act(() => controls?.emitSecond())
    await waitFor(() => {
      expect(container.textContent).toContain('first chunk second chunk')
    })

    act(() => controls?.complete())
    await waitFor(() => {
      expect(container.textContent).toContain('first chunk second chunk')
    })
  })

  it('suppresses the action footer on sealed interim messages, keeping it on the final reply', () => {
    const { container } = render(
      <TranscriptHarness
        messages={[
          userMessage(),
          assistantInterimMessage('Let me check the files.'),
          assistantInterimMessage('Now applying the patch.', 'assistant-interim-2'),
          assistantMessage('All done — patch applied.', false)
        ]}
      />
    )

    // Interim commentary stays visible…
    expect(container.textContent).toContain('Let me check the files.')
    expect(container.textContent).toContain('Now applying the patch.')
    expect(container.textContent).toContain('All done — patch applied.')

    // …but only the turn's final reply carries the copy/refresh action bar.
    const actionBars = container.querySelectorAll('[data-slot="aui_msg-actions"]')
    expect(actionBars).toHaveLength(1)

    const finalRoot = [...container.querySelectorAll('[data-slot="aui_assistant-message-root"]')].find(root =>
      root.textContent?.includes('All done — patch applied.')
    )

    expect(finalRoot?.querySelector('[data-slot="aui_msg-actions"]')).toBeTruthy()
  })

  it('renders assistant provider errors inline', () => {
    render(<MessageHarness message={assistantErrorMessage('OpenRouter rejected the request (403).')} />)

    expect(screen.getByRole('alert').textContent).toContain('OpenRouter rejected the request (403).')
  })

  it('omits the dismiss control when no onDismissError handler is supplied', () => {
    render(<MessageHarness message={assistantErrorMessage('OpenRouter rejected the request (403).')} />)

    expect(screen.queryByRole('button', { name: 'Dismiss error' })).toBeNull()
  })

  it('invokes onDismissError with the errored message id when the dismiss control is clicked', () => {
    const onDismissError = vi.fn()
    render(<DismissibleErrorHarness onDismissError={onDismissError} />)

    const dismiss = screen.getByRole('button', { name: 'Dismiss error' })
    fireEvent.click(dismiss)

    expect(onDismissError).toHaveBeenCalledTimes(1)
    expect(onDismissError).toHaveBeenCalledWith('assistant-error-1')
  })

  // Scroll behavior (follow-at-bottom, escape-on-scroll-up, re-engage) is owned
  // by the use-stick-to-bottom library and covered by its own test suite. We
  // don't re-assert its scrollTop mechanics here — doing so in jsdom (no real
  // layout, spring animation via rAF) only produces brittle change-detector
  // tests. The rendering/streaming-content tests below remain the contract.

  it('renders an incomplete streaming fenced code block as a code card', async () => {
    const { container } = render(<RunningMessageHarness message={assistantMessage('```ts\nconst answer = 42\n')} />)

    await waitFor(() => {
      expect(container.querySelector('[data-slot="code-card"]')).toBeTruthy()
    })

    expect(container.textContent).toContain('const answer = 42')
    expect(container.textContent).not.toContain('```ts')
  })

  it('renders an incomplete streaming reasoning fenced code block as a code card', async () => {
    const { container } = render(<RunningReasoningHarness />)
    const ui = within(container)
    const thinkingToggle = ui.getByRole('button', { name: /thinking/i })

    if (thinkingToggle.getAttribute('aria-expanded') !== 'true') {
      fireEvent.click(thinkingToggle)
    }

    await waitFor(() => {
      expect(container.querySelector('[data-slot="code-card"]')).toBeTruthy()
    })

    await waitFor(() => {
      expect(container.querySelector('[data-slot="aui_reasoning-text"]')?.textContent).toContain('const answer = 42')
    })
    expect(container.textContent).not.toContain('```ts')
  })

  it('preserves the thinking reading position on growth and resumes following at the bottom', () => {
    const { container, rerender } = render(
      <RunningMessageHarness message={assistantReasoningMessage('First thought.', true)} />
    )

    const body = container.querySelector<HTMLDivElement>('[data-slot="aui_thinking-body"]')!
    let height = 600
    let top = 0

    Object.defineProperties(body, {
      clientHeight: { configurable: true, get: () => 160 },
      scrollHeight: { configurable: true, get: () => height },
      scrollTop: {
        configurable: true,
        get: () => top,
        set: (value: number) => {
          top = Math.max(0, Math.min(value, height - body.clientHeight))
        }
      }
    })

    const deliverGrowth = () =>
      act(() => {
        for (const observer of resizeObservers) {
          observer.triggerFor(body.firstElementChild!, height)
        }
      })

    deliverGrowth()
    expect(body.scrollTop).toBe(height - body.clientHeight)
    body.scrollTop = 100
    fireEvent.scroll(body)

    rerender(<RunningMessageHarness message={assistantReasoningMessage('First thought. More reasoning.', true)} />)
    height = 900
    deliverGrowth()
    expect(body.scrollTop).toBe(100)

    body.scrollTop = height - body.clientHeight - 0.5
    fireEvent.scroll(body)
    rerender(
      <RunningMessageHarness
        message={assistantReasoningMessage('First thought. More reasoning. Latest thought.', true)}
      />
    )
    height = 1200
    deliverGrowth()
    expect(body.scrollTop).toBe(height - body.clientHeight)
  })

  it('does not collapse a live thinking preview when the turn settles', async () => {
    const { container, settle } = renderSettlingReasoning()
    const toggle = within(container).getByRole('button', { name: /thinking/i })

    expect(toggle.getAttribute('aria-expanded')).toBe('true')
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')).toBeTruthy()

    settle()

    await waitFor(() => {
      expect(
        within(container)
          .getByRole('button', { name: /thought/i })
          .getAttribute('aria-expanded')
      ).toBe('true')
    })
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')).toBeTruthy()
  })

  it('leaves a settling turn collapsed when the collapsed-by-default preference is enabled', async () => {
    $reasoningCollapsedByDefault.set(true)

    const { container, settle } = renderSettlingReasoning()

    expect(
      within(container)
        .getByRole('button', { name: /thinking/i })
        .getAttribute('aria-expanded')
    ).toBe('false')

    settle()

    await waitFor(() => {
      expect(
        within(container)
          .getByRole('button', { name: /thought/i })
          .getAttribute('aria-expanded')
      ).toBe('false')
    })
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')).toBeNull()
  })

  it('keeps streaming reasoning collapsed by default when the preference is enabled', () => {
    $reasoningCollapsedByDefault.set(true)

    const { container } = render(<RunningReasoningHarness />)
    const thinkingToggle = within(container).getByRole('button', { name: /thinking/i })

    expect(thinkingToggle.getAttribute('aria-expanded')).toBe('false')
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')).toBeNull()

    fireEvent.click(thinkingToggle)

    expect(thinkingToggle.getAttribute('aria-expanded')).toBe('true')
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')?.textContent).toContain('const answer = 42')
  })

  it('keeps streaming reasoning collapsed in the onboarding chat', () => {
    $activeSessionId.set('onboarding-chat')
    $onboardingSession.set({
      connectionId: null,
      runId: 'run-1',
      runtimeId: 'onboarding-chat',
      storedId: 'stored-onboarding'
    })
    $onboardingPhase.set('shown')

    const { container } = render(<RunningReasoningHarness />)

    expect(
      within(container)
        .getByRole('button', { name: /thinking/i })
        .getAttribute('aria-expanded')
    ).toBe('false')
    expect(container.querySelector('[data-slot="aui_reasoning-text"]')).toBeNull()
  })

  it('renders reasoning text without a leading token space', () => {
    const { container } = render(<ReasoningHarness />)
    const ui = within(container)

    // Settled, so the header is past tense — a running block says "Thinking".
    fireEvent.click(ui.getByRole('button', { name: /thought/i }))

    expect(container.querySelector('[data-slot="aui_reasoning-text"]')?.textContent).toBe(
      'The user is asking what this file is.'
    )
  })

  it('groups consecutive reasoning parts under one thinking disclosure', () => {
    const { container } = render(<GroupedReasoningHarness />)

    const disclosures = container.querySelectorAll('[data-slot="aui_thinking-disclosure"]')
    expect(disclosures.length).toBe(1)

    fireEvent.click(disclosures[0].querySelector('button')!)

    const reasoningParts = container.querySelectorAll('[data-slot="aui_reasoning-text"]')
    expect(reasoningParts.length).toBe(2)
    expect(reasoningParts[0]?.textContent).toBe('First thought.')
    expect(reasoningParts[1]?.textContent).toBe('Second thought.')
  })

  it('does not reopen an earlier completed thinking group when a later group is running', () => {
    const { container } = render(<RunningMessageHarness message={assistantSeparatedReasoningMessage()} />)

    const disclosures = container.querySelectorAll('[data-slot="aui_thinking-disclosure"]')
    expect(disclosures.length).toBe(2)

    expect(disclosures[0].querySelector('button')?.getAttribute('aria-expanded')).toBe('false')
    expect(disclosures[1].querySelector('button')?.getAttribute('aria-expanded')).toBe('true')
    expect(container.textContent).not.toContain('Complete first thought.')
    expect(container.textContent).toContain('Interim answer.')
  })

  it('renders completed image generation results in the tool slot', async () => {
    const { container } = render(<MessageHarness message={assistantImageMessage()} />)

    await waitFor(() => {
      expect(screen.getByRole('img', { name: 'Generated image' }).getAttribute('src')).toBe(
        'https://cdn.example/cat.png'
      )
    })
    expect(container.querySelector('[data-slot="aui_generated-image"]')).toBeTruthy()
    expect(screen.queryByRole('status', { name: /rendering image/i })).toBeNull()
  })

  it('uses the normal tool row for failed image generations instead of dropping their error payload', async () => {
    const { container } = render(
      <MessageHarness
        message={assistantImageMessage(false, { error: 'FAL rejected the prompt', image: null, success: false })}
      />
    )

    fireEvent.click(container.querySelector('[data-tool-row] button')!)

    await waitFor(() => {
      expect(container.textContent).toContain('FAL rejected the prompt')
    })
    expect(container.querySelector('[data-slot="aui_generated-image"]')).toBeNull()
    expect(container.textContent).not.toContain('"success":false')
  })

  it('shows the command prompt and exit code for terminal calls', async () => {
    const { container } = render(<MessageHarness message={assistantTerminalMessage()} />)

    fireEvent.click(container.querySelector('[data-tool-row] button')!)

    await waitFor(() => {
      expect(container.textContent).toContain('$ npm run check --workspace=apps/desktop')
      expect(container.textContent).toContain('exit 0')
      expect(container.textContent).toContain('all checks passed')
    })
  })
})