The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
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')
})
})
})