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.

5.7 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import {
  opencodeMessagesToEvents,
  lastOpencodeTurnText,
  windowOpencodeMessages,
  taskStartEvent,
  taskEndEvent,
  extractTaskResult,
  isTaskPart,
  type OcMessage,
  type OcPart,
} from './normalizer.js'

function part(type: string, data: Record<string, unknown>, id = `prt_${type}_${Math.round(Math.random() * 1e6)}`): OcPart {
  return { id, type, data: { type, ...data } }
}
function msg(role: string, parts: OcPart[], id = `msg_${role}`, timeCreated = 1): OcMessage {
  return { id, role, timeCreated, data: { role }, parts }
}

describe('opencode normalizer — replay', () => {
  it('maps a user + assistant (text, reasoning) turn to the shared event shapes', () => {
    const events = opencodeMessagesToEvents([
      msg('user', [part('text', { text: 'what is the BTC price?' })], 'msg_u', 1),
      msg('assistant', [
        part('step-start', {}),
        part('reasoning', { text: 'The user wants the BTC price.' }),
        part('text', { text: '65,374 USD' }),
        part('step-finish', { reason: 'stop' }),
      ], 'msg_a', 2),
    ])
    expect(events.map((e) => e.type)).toEqual(['user_message', 'thinking_delta', 'text_delta', 'done'])
    expect(events[0]).toMatchObject({ type: 'user_message', payload: { content: 'what is the BTC price?' } })
    expect(events[2]).toMatchObject({ type: 'text_delta', payload: { content: '65,374 USD' } })
  })

  it('maps a completed tool part to a Claude-vocabulary tool_start + tool_end', () => {
    const events = opencodeMessagesToEvents([
      msg('assistant', [
        part('tool', { tool: 'webfetch', state: { status: 'completed', input: { url: 'https://x' }, output: 'ok' } }, 'prt_t'),
      ]),
    ])
    const tool = events.filter((e) => e.type === 'tool_start' || e.type === 'tool_end')
    expect(tool[0]).toMatchObject({ type: 'tool_start', payload: { id: 'prt_t', tool: 'WebFetch', input: { url: 'https://x' } } })
    expect(tool[1]).toMatchObject({ type: 'tool_end', payload: { id: 'prt_t', tool: 'WebFetch', output: 'ok', isError: false } })
  })

  it('maps a todowrite tool part to TodoWrite with the todo list intact', () => {
    const todos = [
      { content: 'Fetch BTC price', status: 'completed', priority: 'high' },
      { content: 'Report all prices', status: 'pending', priority: 'high' },
    ]
    const events = opencodeMessagesToEvents([
      msg('assistant', [part('tool', { tool: 'todowrite', state: { status: 'completed', input: { todos }, output: '[]' } }, 'prt_todo')]),
    ])
    const start = events.find((e) => e.type === 'tool_start')
    expect(start).toMatchObject({ type: 'tool_start', payload: { tool: 'TodoWrite', input: { todos } } })
  })

  it('renders a task tool part as a Task card with a sub-agent summary', () => {
    const taskPart = part('tool', {
      tool: 'task',
      state: {
        status: 'completed',
        input: { description: 'Fetch BNB price', prompt: 'fetch BNB', subagent_type: 'general' },
        output: '<task id="ses_child" state="completed">\n<task_result>\n573.92\n</task_result>\n</task>',
        metadata: { sessionId: 'ses_child', parentSessionId: 'ses_parent' },
        time: { start: 1000, end: 3000 },
      },
    }, 'prt_task')
    expect(isTaskPart(taskPart)).toBe(true)

    const start = taskStartEvent(taskPart)
    expect(start).toMatchObject({ type: 'tool_start', payload: { id: 'prt_task', tool: 'Task', input: { subagent_type: 'general', description: 'Fetch BNB price' } } })

    const end = taskEndEvent(taskPart, { totalToolUseCount: 1, totalTokens: 42 })
    expect(end).toMatchObject({
      type: 'tool_end',
      payload: {
        id: 'prt_task',
        tool: 'Task',
        output: '573.92',
        isError: false,
        subagent: { agentId: 'ses_child', agentType: 'general', totalToolUseCount: 1, totalTokens: 42, totalDurationMs: 2000 },
      },
    })
  })

  it('extractTaskResult pulls the <task_result> body, else the raw text', () => {
    expect(extractTaskResult('<task_result>\n42\n</task_result>')).toBe('42')
    expect(extractTaskResult('plain output')).toBe('plain output')
  })

  it('an in-flight tool part emits only tool_start', () => {
    const events = opencodeMessagesToEvents([
      msg('assistant', [part('tool', { tool: 'bash', state: { status: 'running', input: { command: 'ls' } } }, 'prt_r')]),
    ])
    expect(events.filter((e) => e.type === 'tool_start')).toHaveLength(1)
    expect(events.filter((e) => e.type === 'tool_end')).toHaveLength(0)
  })
})

describe('opencode normalizer — recap + window', () => {
  it('lastOpencodeTurnText returns the last user prompt + following assistant text', () => {
    const turn = lastOpencodeTurnText([
      msg('user', [part('text', { text: 'first' })], 'm1', 1),
      msg('assistant', [part('text', { text: 'ignored' })], 'm2', 2),
      msg('user', [part('text', { text: 'who won?' })], 'm3', 3),
      msg('assistant', [part('text', { text: 'Spain won.' })], 'm4', 4),
    ])
    expect(turn).toEqual({ userMessage: 'who won?', assistantText: 'Spain won.' })
  })

  it('windowOpencodeMessages snaps the window start back to a user message', () => {
    const messages = [
      msg('user', [part('text', { text: 'u1' })], 'm1', 1),
      msg('assistant', [part('text', { text: 'a1' })], 'm2', 2),
      msg('user', [part('text', { text: 'u2' })], 'm3', 3),
      msg('assistant', [part('text', { text: 'a2' })], 'm4', 4),
    ]
    const w = windowOpencodeMessages(messages, { limit: 2 })
    expect(w.window[0].role).toBe('user') // snapped back to m3
    expect(w.hasMore).toBe(true)
    expect(w.oldestCursor).toBe('opencode:2')
  })

  it('windowOpencodeMessages flags a malformed cursor as stale', () => {
    const w = windowOpencodeMessages([], { limit: 2, before: 'not-a-cursor' })
    expect(w.staleCursor).toBe(true)
  })
})