Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
38.0 KB
Raw Blame
// @vitest-environment jsdom
import React from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
import type { ProgressStep, TaskProgress } from '../../uiTypes'
import { ProgressStepper } from '../ProgressStepper'

// ── CSS import stub ───────────────────────────────────────────────────────────

vi.mock('../ArtifactsBadge.css', () => ({}))

afterEach(() => {
  cleanup()
})

// ── Mock ArtifactsBadge to isolate ProgressStepper ────────────────────────────

vi.mock('../ArtifactsBadge', () => ({
  ArtifactsBadge: ({ hostRef, artifactNames }: { hostRef: string; artifactNames?: string[] }) => (
    <div data-testid="artifacts-badge">
      Artifacts for {hostRef}: {(artifactNames || []).join(', ')}
    </div>
  ),
}))

// ── Helpers ───────────────────────────────────────────────────────────────────

function makeStep(overrides: Partial<ProgressStep> = {}): ProgressStep {
  return {
    toolCallId: 'tc-1',
    toolName: 'mongodb__find',
    displayName: 'MongoDB',
    intentSummary: 'Query users collection',
    iteration: 0,
    stepIndex: 0,
    totalSteps: 3,
    state: 'completed',
    durationMs: 150,
    ...overrides,
  }
}

function makeProgress(overrides: Partial<TaskProgress> = {}): TaskProgress {
  return {
    status: 'active',
    steps: [],
    currentIteration: 0,
    ...overrides,
  }
}

function expandDetails() {
  fireEvent.click(screen.getByText('More details'))
}

describe('ProgressStepper approval input preview', () => {
  it('shows the pending command as text before approval and does not decide automatically', () => {
    const onApprove = vi.fn()
    const onDeny = vi.fn()
    const command = `node -e 'console.log("<img src=x onerror=alert(1)>")'`
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'preview-request',
            displayName: 'Shell',
            inputPreview: { text: command, truncated: false },
          },
        })}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )
    const preview = screen.getByTestId('approval-input-preview')
    expect(preview.textContent).toBe(command)
    expect(preview.querySelector('img')).toBeNull()
    expect(onApprove).not.toHaveBeenCalled()
    expect(onDeny).not.toHaveBeenCalled()
    fireEvent.click(screen.getByTestId('approval-approve-btn'))
    expect(onApprove).toHaveBeenCalledTimes(1)
    expect(onDeny).not.toHaveBeenCalled()
  })

  it('labels a shortened or redacted command as an incomplete preview', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'preview-request',
            displayName: 'Shell',
            inputPreview: { text: 'node', truncated: true },
          },
        })}
        onDeny={vi.fn()}
      />
    )
    expect(screen.getByTestId('approval-input-preview').textContent).toContain(
      'incomplete or changed by redaction'
    )
  })

  it('associates completed and live output panels with their own tool call', () => {
    const preview = {
      headLines: ['bounded-output'],
      tailLines: [],
      totalLines: 1,
      truncated: false,
    }
    render(
      <ProgressStepper
        progress={makeProgress({
          steps: [
            makeStep({ toolCallId: 'completed-call', outputPreview: preview }),
            makeStep({ toolCallId: 'live-call', state: 'running', liveOutputPreview: preview }),
          ],
        })}
      />
    )
    expandDetails()
    fireEvent.click(screen.getByTestId('step-row-completed-call'))
    fireEvent.click(screen.getByTestId('step-row-live-call'))
    expect(
      screen
        .getAllByTestId('step-output-panel')
        .map(panel => panel.getAttribute('data-tool-call-id'))
    ).toEqual(['completed-call', 'live-call'])
  })
})

// ── Tests ─────────────────────────────────────────────────────────────────────

describe('ProgressStepper — null/empty states', () => {
  it('returns null when progress is undefined', () => {
    const { container } = render(<ProgressStepper progress={undefined} />)
    expect(container.innerHTML).toBe('')
  })

  it('returns null when completed with zero steps', () => {
    const { container } = render(
      <ProgressStepper progress={makeProgress({ status: 'completed', steps: [] })} />
    )
    expect(container.innerHTML).toBe('')
  })
})

describe('ProgressStepper — connecting status', () => {
  it('renders connecting indicator', () => {
    render(<ProgressStepper progress={makeProgress({ status: 'connecting' })} />)
    expect(screen.getByTestId('progress-stepper')).toBeDefined()
    expect(screen.getByText('Connecting')).toBeDefined()
  })
})

describe('ProgressStepper — error status', () => {
  it('renders error message', () => {
    render(<ProgressStepper progress={makeProgress({ status: 'error' })} />)
    expect(screen.getByText('Progress stream error')).toBeDefined()
  })
})

describe('ProgressStepper — active status with steps', () => {
  it('hides step list by default behind More details toggle', () => {
    const step = makeStep({ state: 'running', stepIndex: 1, totalSteps: 5 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expect(screen.getByText('More details')).toBeDefined()
    expect(screen.queryByText('MongoDB')).toBeNull()
  })

  it('uses the current running step as the visible progress headline', () => {
    const step = makeStep({ state: 'running', intentSummary: 'Query users collection' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expect(screen.getByText('Using MongoDB')).toBeDefined()
    expect(screen.queryByText('Agent is thinking')).toBeNull()
  })

  it('falls back to LLM elapsed time before a tool step arrives', () => {
    render(
      <ProgressStepper
        progress={makeProgress({ status: 'active', steps: [], llmElapsedMs: 45_000 })}
      />
    )
    expect(screen.getByText('Thinking 45s')).toBeDefined()
  })

  it('keeps the latest step in the headline while waiting on the next LLM turn', () => {
    const step = makeStep({ state: 'completed', intentSummary: 'Query users collection' })
    render(
      <ProgressStepper
        progress={makeProgress({ status: 'active', steps: [step], llmElapsedMs: 45_000 })}
      />
    )
    expect(screen.getByText('Thinking after MongoDB (45s)')).toBeDefined()
  })

  it('shows only one action phrase for the latest completed step', () => {
    const step = makeStep({
      state: 'completed',
      displayName: 'Mcp-fred',
      intentSummary: 'Using Mcp-fred to inspect project files',
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expect(screen.getByText('Finished Mcp-fred')).toBeDefined()
    expect(screen.queryByText(/Finished Mcp-fred: Using Mcp-fred/)).toBeNull()
  })

  it('renders tool name after expanding details', () => {
    const step = makeStep({ state: 'running', stepIndex: 1, totalSteps: 5 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.queryByText('Step 2/5')).toBeNull()
    expect(screen.getByText('MongoDB')).toBeDefined()
  })

  it('shows running indicator for active step after expanding', () => {
    const step = makeStep({ state: 'running' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('running...')).toBeDefined()
  })

  it('shows duration for completed step after expanding', () => {
    const step = makeStep({ state: 'completed', durationMs: 1500 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('1.5s')).toBeDefined()
  })

  it('shows error summary for errored step after expanding', () => {
    const step = makeStep({ state: 'error', errorSummary: 'Connection refused' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('Connection refused')).toBeDefined()
  })

  it('extracts MCP function name from double-underscore toolName after expanding', () => {
    const step = makeStep({ toolName: 'mongodb__find_documents', displayName: 'MongoDB' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('find_documents')).toBeDefined()
  })
})

describe('ProgressStepper — completed status', () => {
  it('shows summary with tool count and expand button', () => {
    const steps = [
      makeStep({ toolCallId: 'tc-1', displayName: 'MongoDB', durationMs: 100 }),
      makeStep({
        toolCallId: 'tc-2',
        displayName: 'Redis',
        durationMs: 200,
        toolName: 'redis__get',
      }),
    ]
    render(<ProgressStepper progress={makeProgress({ status: 'completed', steps })} />)
    expect(screen.getByText(/More details/)).toBeDefined()
    expect(screen.getByText(/2 tools/)).toBeDefined()
    expect(screen.getByTestId('progress-expand-btn')).toBeDefined()
  })

  it('toggles expanded step list on button click', () => {
    const steps = [makeStep({ toolCallId: 'tc-1' })]
    render(<ProgressStepper progress={makeProgress({ status: 'completed', steps })} />)
    const btn = screen.getByTestId('progress-expand-btn')
    expect(screen.getByText(/More details/)).toBeDefined()

    fireEvent.click(btn)
    expect(screen.getByText('Hide details')).toBeDefined()
    expect(screen.getByText('MongoDB')).toBeDefined()

    fireEvent.click(btn)
    expect(screen.getByText(/More details/)).toBeDefined()
  })

  it('shows ArtifactsBadge inside expanded details for completed runs when hostRef is provided', () => {
    const steps = [
      makeStep({
        toolCallId: 'tc-1',
        toolName: 'clerum__generate_pdf',
        outputPreview: {
          headLines: ['Generated report.pdf'],
          tailLines: [],
          totalLines: 1,
          truncated: false,
        },
      }),
    ]
    render(
      <ProgressStepper progress={makeProgress({ status: 'completed', steps })} hostRef="chatllm" />
    )
    expect(screen.queryByTestId('artifacts-badge')).toBeNull()
    fireEvent.click(screen.getByTestId('progress-expand-btn'))
    expect(screen.getByTestId('artifacts-badge')).toBeDefined()
    expect(screen.getByText(/Artifacts for chatllm: report\.pdf/)).toBeDefined()
  })

  it('does not show ArtifactsBadge without filenames in progress output', () => {
    const steps = [makeStep({ toolCallId: 'tc-1', toolName: 'mongodb__find' })]
    render(
      <ProgressStepper progress={makeProgress({ status: 'completed', steps })} hostRef="chatllm" />
    )
    expect(screen.queryByTestId('artifacts-badge')).toBeNull()
  })

  it('does NOT show ArtifactsBadge when hostRef is not provided', () => {
    const steps = [makeStep({ toolCallId: 'tc-1', toolName: 'clerum__generate_pdf' })]
    render(<ProgressStepper progress={makeProgress({ status: 'completed', steps })} />)
    expect(screen.queryByTestId('artifacts-badge')).toBeNull()
  })
})

describe('ProgressStepper — suspended status (approval flow)', () => {
  it("shows 'Waiting for approval...' when suspended without suspendedInfo", () => {
    render(<ProgressStepper progress={makeProgress({ status: 'suspended' })} />)
    expect(screen.getByText('Waiting for approval...')).toBeDefined()
  })

  it('announces the suspended state to assistive tech via a polite live region (R4-L8c)', () => {
    // The label that changes when a task parks on approval/connect/OAuth must be a
    // live region so a screen reader announces the transition without stealing focus.
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: { requestId: 'req-1', displayName: 'Tool X' },
        })}
      />
    )
    const status = screen.getByRole('status')
    expect(status.textContent).toBe('Tool X requires approval')
    expect(status.getAttribute('aria-live')).toBe('polite')
    expect(status.getAttribute('aria-atomic')).toBe('true')
  })

  it('shows tool display name when suspendedInfo is populated', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Dangerous Tool',
          },
        })}
      />
    )
    expect(screen.getByText('Dangerous Tool requires approval')).toBeDefined()
  })

  it('shows the internal tool function name when approval display name is generic', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            toolName: 'clerum__plot_pnl',
            displayName: 'Clerum',
          },
        })}
      />
    )
    expect(screen.getByText('Clerum plot_pnl requires approval')).toBeDefined()
  })

  it('renders Approve button when suspendedInfo and onApprove are provided', () => {
    const onApprove = vi.fn()
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
        onApprove={onApprove}
      />
    )
    const btn = screen.getByTestId('approval-approve-btn')
    expect(btn).toBeDefined()
    expect(btn.textContent).toBe('Approve')
  })

  it('renders Deny button when suspendedInfo and onDeny are provided', () => {
    const onDeny = vi.fn()
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
        onDeny={onDeny}
      />
    )
    const btn = screen.getByTestId('approval-deny-btn')
    expect(btn).toBeDefined()
    expect(btn.textContent).toBe('Deny')
  })

  it('does NOT render Approve/Deny buttons when suspendedInfo is missing', () => {
    const onApprove = vi.fn()
    const onDeny = vi.fn()
    render(
      <ProgressStepper
        progress={makeProgress({ status: 'suspended' })}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )
    expect(screen.queryByTestId('approval-approve-btn')).toBeNull()
    expect(screen.queryByTestId('approval-deny-btn')).toBeNull()
  })

  it('does NOT render Approve/Deny buttons when callbacks are not provided', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
      />
    )
    expect(screen.queryByTestId('approval-approve-btn')).toBeNull()
    expect(screen.queryByTestId('approval-deny-btn')).toBeNull()
  })

  it("calls onApprove callback and shows 'Approving...' on click", () => {
    const onApprove = vi.fn()
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
        onApprove={onApprove}
      />
    )

    const btn = screen.getByTestId('approval-approve-btn')
    fireEvent.click(btn)

    expect(onApprove).toHaveBeenCalledOnce()
    expect(btn.textContent).toBe('Approving...')
  })

  it('calls onDeny callback and disables buttons on click', () => {
    const onApprove = vi.fn()
    const onDeny = vi.fn()
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )

    const denyBtn = screen.getByTestId('approval-deny-btn')
    fireEvent.click(denyBtn)

    expect(onDeny).toHaveBeenCalledOnce()
    // After clicking, both buttons should be disabled
    const approveBtn = screen.getByTestId('approval-approve-btn')
    expect(approveBtn.hasAttribute('disabled')).toBe(true)
    expect(denyBtn.hasAttribute('disabled')).toBe(true)
  })

  // A plain approval covers one tool for the task, so another tool in the same task
  // suspends again (shell_exec approved, then http_request). The stepper stays mounted.
  it.each([
    ['after the task resumed', true],
    ['directly from the previous suspension', false],
  ])('enables the buttons of a later suspension in the same task (%s)', (_label, resumed) => {
    const onApprove = vi.fn()
    const onDeny = vi.fn()
    const suspended = (requestId: string, displayName: string) =>
      makeProgress({ status: 'suspended', suspendedInfo: { requestId, displayName } })
    const { rerender } = render(
      <ProgressStepper
        progress={suspended('req-1', 'Shell')}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )

    fireEvent.click(screen.getByTestId('approval-approve-btn'))
    expect(onApprove).toHaveBeenCalledOnce()
    // Witness: the decided card is locked against a second submission.
    expect(screen.getByTestId('approval-approve-btn').hasAttribute('disabled')).toBe(true)
    rerender(
      <ProgressStepper
        progress={suspended('req-1', 'Shell')}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )
    expect(screen.getByTestId('approval-deny-btn').hasAttribute('disabled')).toBe(true)

    if (resumed) {
      rerender(
        <ProgressStepper
          progress={makeProgress({ status: 'active' })}
          onApprove={onApprove}
          onDeny={onDeny}
        />
      )
    }
    rerender(
      <ProgressStepper
        progress={suspended('req-2', 'HTTP')}
        onApprove={onApprove}
        onDeny={onDeny}
      />
    )

    expect(screen.getByText('HTTP requires approval')).toBeDefined()
    const approveBtn = screen.getByTestId('approval-approve-btn')
    const denyBtn = screen.getByTestId('approval-deny-btn')
    expect(approveBtn.hasAttribute('disabled')).toBe(false)
    expect(approveBtn.textContent).toBe('Approve')
    expect(denyBtn.hasAttribute('disabled')).toBe(false)
    fireEvent.click(denyBtn)
    expect(onDeny).toHaveBeenCalledOnce()
  })

  it('renders step list when suspended with existing steps after expanding details', () => {
    const steps = [makeStep({ toolCallId: 'tc-1', state: 'completed', displayName: 'MongoDB' })]
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          steps,
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'Tool X',
          },
        })}
        onApprove={vi.fn()}
      />
    )
    expect(screen.getByTestId('approval-approve-btn')).toBeDefined()
    expandDetails()
    expect(screen.getByText('MongoDB')).toBeDefined()
  })
})

describe('ProgressStepper — connect_required suspension (U5, T5 invariant c)', () => {
  const connectProgress = () =>
    makeProgress({
      status: 'suspended',
      suspendedInfo: {
        requestId: 'req-1',
        displayName: 'monday tool',
        reason: 'connect_required',
        mcpServerName: 'monday',
      },
    })

  it('renders a "Connect <server>" prompt, NOT the generic approval prompt', () => {
    render(<ProgressStepper progress={connectProgress()} onConnect={vi.fn()} />)
    expect(screen.getByText('Connect monday to continue')).toBeDefined()
    // The generic approval label / buttons must NOT appear for a connect suspension.
    expect(screen.queryByText(/requires approval/)).toBeNull()
    expect(screen.queryByTestId('approval-approve-btn')).toBeNull()
    expect(screen.queryByTestId('approval-deny-btn')).toBeNull()
  })

  it('renders a Connect button that fires onConnect and shows "Connecting..." on click', () => {
    const onConnect = vi.fn()
    render(<ProgressStepper progress={connectProgress()} onConnect={onConnect} />)
    const btn = screen.getByTestId('connect-mcp-btn')
    expect(btn.textContent).toBe('Connect monday')
    fireEvent.click(btn)
    expect(onConnect).toHaveBeenCalledOnce()
    expect(btn.textContent).toBe('Connecting...')
  })

  it('does NOT render Approve/Deny even when those callbacks are supplied (connect wins)', () => {
    render(
      <ProgressStepper
        progress={connectProgress()}
        onApprove={vi.fn()}
        onDeny={vi.fn()}
        onConnect={vi.fn()}
      />
    )
    expect(screen.getByTestId('connect-mcp-btn')).toBeDefined()
    expect(screen.queryByTestId('approval-approve-btn')).toBeNull()
    expect(screen.queryByTestId('approval-deny-btn')).toBeNull()
  })

  it('a generic approval suspension still renders Approve/Deny (connect branch is scoped)', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: { requestId: 'req-1', displayName: 'Tool X' },
        })}
        onApprove={vi.fn()}
        onDeny={vi.fn()}
        onConnect={vi.fn()}
      />
    )
    expect(screen.getByTestId('approval-approve-btn')).toBeDefined()
    expect(screen.queryByTestId('connect-mcp-btn')).toBeNull()
  })

  it('connect_required WITHOUT an actionable onConnect never renders Approve/Deny (R3-L2)', () => {
    // Defensive: if mcpServerName were ever empty the caller leaves onConnect
    // undefined. This must NOT fall back to Approve/Deny — approving would resume
    // with no grant → another 401 → a re-suspension loop. It renders an
    // explanatory suspended state instead; Cancel remains available.
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'suspended',
          suspendedInfo: {
            requestId: 'req-1',
            displayName: 'monday tool',
            reason: 'connect_required',
            mcpServerName: '',
          },
        })}
        onApprove={vi.fn()}
        onDeny={vi.fn()}
        onCancel={vi.fn()}
        // onConnect intentionally omitted
      />
    )
    // Nothing to connect to, and — the fix — no Approve/Deny loop trap either.
    expect(screen.queryByTestId('connect-mcp-btn')).toBeNull()
    expect(screen.queryByTestId('approval-approve-btn')).toBeNull()
    expect(screen.queryByTestId('approval-deny-btn')).toBeNull()
    // An explanatory suspended state, with Cancel still available.
    expect(screen.getByText(/must be reconnected to continue/)).toBeDefined()
    expect(screen.getByTestId('progress-cancel-btn')).toBeDefined()
  })
})

describe('ProgressStepper — iteration dividers', () => {
  it("shows 'Thinking further...' divider between different iterations after expanding", () => {
    const steps = [
      makeStep({ toolCallId: 'tc-1', iteration: 0, displayName: 'Step A' }),
      makeStep({ toolCallId: 'tc-2', iteration: 1, displayName: 'Step B' }),
    ]
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps })} />)
    expandDetails()
    expect(screen.getByText('Thinking further...')).toBeDefined()
  })
})

describe('ProgressStepper — duration formatting', () => {
  it('formats milliseconds < 1000 as ms', () => {
    const step = makeStep({ state: 'completed', durationMs: 42 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('42ms')).toBeDefined()
  })

  it('formats milliseconds >= 1000 as seconds', () => {
    const step = makeStep({ state: 'completed', durationMs: 2345 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('2.3s')).toBeDefined()
  })
})

describe('ProgressStepper — per-step token usage', () => {
  it('renders duration · compact token count with a breakdown tooltip (no cache → 2 figures)', () => {
    const step = makeStep({
      state: 'completed',
      durationMs: 1500,
      tokens: { input: 12_000, output: 300 },
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const span = screen.getByText('1.5s · 12.3k')
    // Compute the expected separator via toLocaleString so the assertion is
    // locale-agnostic (same convention as sessionTokensIndicator.test.tsx).
    expect(span.getAttribute('title')).toBe(`Input ${(12_000).toLocaleString()} · Output 300`)
  })

  it('includes cache read/write in the tooltip when the provider reported cache (4 figures)', () => {
    const step = makeStep({
      state: 'completed',
      durationMs: 1500,
      tokens: { input: 12_000, output: 300, cacheRead: 9_000, cacheWrite: 0 },
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const span = screen.getByText('1.5s · 12.3k')
    expect(span.getAttribute('title')).toBe(
      `Input ${(12_000).toLocaleString()} · Output 300 · Cache read ${(9_000).toLocaleString()} · Cache write 0`
    )
  })

  it('renders only the duration when the step carries no tokens (post-approval steps)', () => {
    const step = makeStep({ state: 'completed', durationMs: 1500, tokens: undefined })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const span = screen.getByText('1.5s')
    expect(span.textContent).toBe('1.5s')
    expect(span.getAttribute('title')).toBeNull()
  })

  it('does not render tokens on errored steps even when present', () => {
    const step = makeStep({
      state: 'error',
      errorSummary: 'Connection refused',
      tokens: { input: 12_000, output: 300 },
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('Connection refused')).toBeDefined()
    expect(screen.queryByText(/12\.3k/)).toBeNull()
  })
})

describe('ProgressStepper — inputPreview', () => {
  it('renders inputPreview inline in active step row after expanding', () => {
    const step = makeStep({
      state: 'running',
      toolName: 'shell_exec',
      displayName: 'Shell',
      inputPreview: 'git status',
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('git status')).toBeDefined()
  })

  it('renders inputPreview in completed step row after expanding', () => {
    const step = makeStep({
      state: 'completed',
      toolName: 'shell_exec',
      displayName: 'Shell',
      inputPreview: 'npm run build',
      durationMs: 9200,
    })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('npm run build')).toBeDefined()
  })

  it('does not render inputPreview span when not present after expanding', () => {
    const step = makeStep({ state: 'completed', inputPreview: undefined })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.queryByTestId('step-input-preview')).toBeNull()
  })
})

describe('ProgressStepper — outputPreview expand', () => {
  const outputPreview = {
    headLines: ['stdout:', 'On branch master', 'Changes not staged:'],
    tailLines: ['modified: file.ts', 'modified: other.ts', 'no changes added'],
    totalLines: 15,
    truncated: true,
  }

  it('does not show output panel before expanding details', () => {
    const step = makeStep({ state: 'completed', outputPreview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expect(screen.queryByTestId('step-output-panel')).toBeNull()
  })

  it('expands output panel on row click after expanding details', () => {
    const step = makeStep({ state: 'completed', outputPreview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const row = screen.getByTestId('step-row-tc-1')
    fireEvent.click(row)
    const panel = screen.getByTestId('step-output-panel')
    expect(panel).toBeDefined()
    expect(panel.textContent).toContain('no changes added')
    expect(panel.textContent).toContain('modified: file.ts')
    expect(panel.textContent).not.toContain('stdout:')
    expect(screen.queryByText(/lines hidden/)).toBeNull()
  })

  it('collapses output panel on second click', () => {
    const step = makeStep({ state: 'completed', outputPreview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const row = screen.getByTestId('step-row-tc-1')
    fireEvent.click(row)
    expect(screen.getByTestId('step-output-panel')).toBeDefined()
    fireEvent.click(row)
    expect(screen.queryByTestId('step-output-panel')).toBeNull()
  })

  it('auto-expands error rows with outputPreview after expanding details', () => {
    const step = makeStep({ state: 'error', outputPreview, errorSummary: 'Failed' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByTestId('step-output-panel')).toBeDefined()
  })

  it('does not render output panel for running steps after expanding details', () => {
    const step = makeStep({ state: 'running', outputPreview: undefined })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.queryByTestId('step-output-panel')).toBeNull()
  })

  it('shows expand chevron on expandable rows after expanding details', () => {
    const step = makeStep({ state: 'completed', outputPreview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const row = screen.getByTestId('step-row-tc-1')
    expect(row.querySelector('.stepper-step-chevron')).toBeDefined()
  })

  it('error output panel has error styling after expanding details', () => {
    const step = makeStep({ state: 'error', outputPreview, errorSummary: 'Failed' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const panel = screen.getByTestId('step-output-panel')
    expect(panel.classList.contains('stepper-step-output--error')).toBe(true)
  })

  it('renders non-truncated output without hidden lines indicator', () => {
    const smallPreview = {
      headLines: ['line1', 'line2'],
      tailLines: [],
      totalLines: 2,
      truncated: false,
    }
    const step = makeStep({ state: 'completed', outputPreview: smallPreview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const row = screen.getByTestId('step-row-tc-1')
    fireEvent.click(row)
    const panel = screen.getByTestId('step-output-panel')
    expect(panel.textContent).toContain('line1')
    expect(panel.textContent).toContain('line2')
    expect(screen.queryByText(/lines hidden/)).toBeNull()
  })
})

describe('ProgressStepper — cancel button', () => {
  it('does NOT render cancel button when onCancel is not provided', () => {
    render(<ProgressStepper progress={makeProgress({ status: 'active' })} />)
    expect(screen.queryByTestId('progress-cancel-btn')).toBeNull()
  })

  it('renders cancel button on active status when onCancel is provided', () => {
    const onCancel = vi.fn()
    render(<ProgressStepper progress={makeProgress({ status: 'active' })} onCancel={onCancel} />)
    const btn = screen.getByTestId('progress-cancel-btn')
    expect(btn).toBeDefined()
    expect(btn.getAttribute('aria-label')).toBe('Stop agent')
    expect(btn.textContent).toBe('■')
  })

  it('renders cancel button on connecting status when onCancel is provided', () => {
    const onCancel = vi.fn()
    render(
      <ProgressStepper progress={makeProgress({ status: 'connecting' })} onCancel={onCancel} />
    )
    expect(screen.getByTestId('progress-cancel-btn')).toBeDefined()
  })

  it('renders cancel button on suspended status when onCancel is provided', () => {
    const onCancel = vi.fn()
    render(<ProgressStepper progress={makeProgress({ status: 'suspended' })} onCancel={onCancel} />)
    expect(screen.getByTestId('progress-cancel-btn')).toBeDefined()
  })

  it('calls onCancel and toggles stop button state on click', () => {
    const onCancel = vi.fn()
    render(<ProgressStepper progress={makeProgress({ status: 'active' })} onCancel={onCancel} />)
    const btn = screen.getByTestId('progress-cancel-btn')
    fireEvent.click(btn)
    expect(onCancel).toHaveBeenCalledOnce()
    expect(btn.getAttribute('aria-label')).toBe('Stopping agent')
    expect(btn.textContent).toBe('■')
    expect(btn.hasAttribute('disabled')).toBe(true)
  })
})

describe('ProgressStepper — cancelled terminal state', () => {
  it('renders Cancelled badge', () => {
    render(<ProgressStepper progress={makeProgress({ status: 'cancelled' })} />)
    expect(screen.getByText('Cancelled')).toBeDefined()
  })

  it('shows cancelReason when present', () => {
    render(
      <ProgressStepper
        progress={makeProgress({
          status: 'cancelled',
          cancelReason: 'User requested cancellation',
        })}
      />
    )
    expect(screen.getByText('User requested cancellation')).toBeDefined()
  })

  it('does not show cancel button in cancelled state even when onCancel is provided', () => {
    const onCancel = vi.fn()
    render(<ProgressStepper progress={makeProgress({ status: 'cancelled' })} onCancel={onCancel} />)
    expect(screen.queryByTestId('progress-cancel-btn')).toBeNull()
  })

  it('renders partial steps that ran before cancellation after expanding details', () => {
    const steps = [makeStep({ toolCallId: 'tc-1', displayName: 'MongoDB', state: 'completed' })]
    render(<ProgressStepper progress={makeProgress({ status: 'cancelled', steps })} />)
    expandDetails()
    expect(screen.getByText('MongoDB')).toBeDefined()
  })
})

describe('ProgressStepper — running step with elapsed + live output', () => {
  it('shows "running..." fallback when elapsedMs is absent after expanding', () => {
    const step = makeStep({ state: 'running' })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('running...')).toBeDefined()
  })

  it('shows elapsed time when elapsedMs is present (seconds-only) after expanding', () => {
    const step = makeStep({ state: 'running', elapsedMs: 45_000 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('running · 45s')).toBeDefined()
  })

  it('shows elapsed time formatted as minutes+seconds (mmMsss) after expanding', () => {
    const step = makeStep({ state: 'running', elapsedMs: 150_000 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    expect(screen.getByText('running · 2m30s')).toBeDefined()
  })

  it('running step is NOT expandable when liveOutputPreview is absent after expanding details', () => {
    const step = makeStep({ state: 'running', elapsedMs: 1000 })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    // No step-level chevron should be rendered (details-toggle chevron is separate).
    expect(screen.queryByTestId('step-row-tc-1')?.querySelector('.stepper-step-chevron')).toBeNull()
  })

  it('running step IS expandable when liveOutputPreview is present after expanding details', () => {
    const preview = {
      headLines: ['npm install starting'],
      tailLines: ['done'],
      totalLines: 10,
      truncated: true,
    }
    const step = makeStep({ state: 'running', elapsedMs: 1000, liveOutputPreview: preview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()
    const row = screen.getByTestId('step-row-tc-1')
    expect(row.querySelector('.stepper-step-chevron')).toBeDefined()
  })

  it('clicking the chevron on a running step expands the OutputPanel with liveOutputPreview', () => {
    const preview = {
      headLines: ['npm install starting'],
      tailLines: ['installing [email protected]'],
      totalLines: 42,
      truncated: true,
    }
    const step = makeStep({ state: 'running', elapsedMs: 1000, liveOutputPreview: preview })
    render(<ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />)
    expandDetails()

    const row = screen.getByTestId(`step-row-${step.toolCallId}`)
    fireEvent.click(row)

    const panel = screen.getByTestId('step-output-panel')
    expect(panel.textContent).toContain('installing [email protected]')
    expect(panel.textContent).not.toContain('npm install starting')
  })

  it('open OutputPanel auto-refreshes when liveOutputPreview updates on subsequent tool_progress events', () => {
    const initialPreview = {
      headLines: ['line-1'],
      tailLines: ['line-5'],
      totalLines: 5,
      truncated: false,
    }
    const step = makeStep({ state: 'running', elapsedMs: 5000, liveOutputPreview: initialPreview })
    const { rerender } = render(
      <ProgressStepper progress={makeProgress({ status: 'active', steps: [step] })} />
    )
    expandDetails()

    fireEvent.click(screen.getByTestId(`step-row-${step.toolCallId}`))
    let panel = screen.getByTestId('step-output-panel')
    expect(panel.textContent).toContain('line-5')
    expect(panel.textContent).not.toContain('line-10')

    const updatedPreview = {
      headLines: ['line-1'],
      tailLines: ['line-10'],
      totalLines: 10,
      truncated: true,
    }
    const updatedStep = { ...step, elapsedMs: 10000, liveOutputPreview: updatedPreview }
    rerender(
      <ProgressStepper progress={makeProgress({ status: 'active', steps: [updatedStep] })} />
    )

    panel = screen.getByTestId('step-output-panel')
    expect(panel.textContent).toContain('line-10')
    expect(panel.textContent).not.toContain('line-1\n')
    expect(panel.textContent).not.toContain('lines hidden')
  })
})