Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

4.8 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import { readFileSync } from 'fs'
import { fileURLToPath } from 'url'
import { ampThreadToEvents } from './threadExport.js'

/**
 * A REAL `amp threads export` payload — one web-search turn, home directory scrubbed and the scraped
 * page text trimmed. This is the shape history is served from, so the fixture is Amp's own export rather
 * than anything this adapter writes.
 */
function messages(): Record<string, unknown>[] {
  const p = fileURLToPath(new URL('../../lib/__fixtures__/amp-thread-export.json', import.meta.url))
  return (JSON.parse(readFileSync(p, 'utf-8')) as { messages: Record<string, unknown>[] }).messages
}

describe('amp thread export → history', () => {
  it('renders the turn as a conversation', () => {
    const events = ampThreadToEvents(messages())
    // The measured order. Note thinking lands AFTER the tool, not before it: the first assistant message
    // carries an empty `thinking` (withheld by the provider, dropped here) and the second carries the
    // real one alongside the answer.
    expect(events.map((e) => e.type)).toEqual([
      'user_message', 'tool_start', 'tool_end', 'thinking_delta', 'text_delta', 'done',
    ])
    expect(events[0]).toMatchObject({ payload: { content: 'gia BTC di' } })
  })

  /**
   * The point of reading Amp's store instead of the local transcript: `web_search` runs on Amp's server,
   * fires no client event, and so never reached the JSONL written by an older plugin. It is in the export.
   */
  it('carries the server-run tool the local transcript never saw', () => {
    const events = ampThreadToEvents(messages())
    const start = events.find((e) => e.type === 'tool_start')
    const end = events.find((e) => e.type === 'tool_end')
    expect(start).toMatchObject({ payload: { tool: 'WebSearch' } })
    expect(end).toMatchObject({ payload: { tool: 'WebSearch', isError: false } })
    expect((start as { payload: { id: string } }).payload.id)
      .toBe((end as { payload: { id: string } }).payload.id)
  })

  it('reduces the search result to its sources, from the export\'s nested shape', () => {
    const end = ampThreadToEvents(messages()).find((e) => e.type === 'tool_end')
    const output = (end as { payload: { output: string } }).payload.output
    // `{run:{result:[{title,url,excerpts}]}}` — one level deeper than the live event's shape.
    expect(output).toContain('https://')
    expect(output).not.toContain('excerpts')
  })

  it('drops reasoning the provider withheld instead of drawing an empty bubble', () => {
    // Amp exports reasoning under `thinking`, not `text`. It is often WITHHELD — an OpenAI-backed turn
    // carries `thinking: ""` and an opaque id — and an empty bubble is worse than none.
    const withheld = [{ role: 'assistant', content: [{ type: 'thinking', thinking: '', signature: '' }] }]
    expect(ampThreadToEvents(withheld).map((e) => e.type)).toEqual(['done'])
    // When it IS present it renders, which the fixture turn proves.
    expect(ampThreadToEvents(messages()).some((e) => e.type === 'thinking_delta')).toBe(true)
  })

  it('pairs a result by toolUseID, which is not the key other engines use', () => {
    const withSnakeCase = [{
      role: 'assistant',
      content: [{ type: 'tool_use', id: 'TU-1', name: 'shell_command', input: { command: 'ls' } }],
    }, {
      role: 'user',
      content: [{ type: 'tool_result', tool_use_id: 'TU-1', run: { result: 'ok' } }],
    }]
    const events = ampThreadToEvents(withSnakeCase)
    expect(events.find((e) => e.type === 'tool_end')).toMatchObject({ payload: { tool: 'Bash' } })
  })

  /**
   * The consumers already render `WebSearch` from `query`; teaching each of them Amp's spelling would be
   * the wrong layer. The adapter adapts — same rule muse's `TodoWrite` reshape follows.
   */
  it("hands the search card a `query`, because that is what the surfaces read", () => {
    const start = ampThreadToEvents(messages()).find((e) => e.type === 'tool_start')
    const input = (start as { payload: { input: Record<string, unknown> } }).payload.input
    expect(input.query).toBe(input.objective)
    // The original keys survive, so the expanded card still shows what Amp was actually given.
    expect(input.objective).toBeTruthy()
  })

  it('falls back to the queries when there is no objective', () => {
    const noObjective = [{
      role: 'assistant',
      content: [{ type: 'tool_use', id: 'TU-1', name: 'web_search', input: { search_queries: ['btc price', 'eth price'] } }],
    }]
    const start = ampThreadToEvents(noObjective).find((e) => e.type === 'tool_start')
    expect((start as { payload: { input: Record<string, unknown> } }).payload.input.query).toBe('btc price, eth price')
  })

  it('survives a thread with nothing in it', () => {
    expect(ampThreadToEvents([])).toEqual([{ type: 'done', payload: { result: 'success' } }])
  })
})