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.

6.1 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import { newTurnState } from '../../lib/normalize.js'
import {
  devinMessageToEvents,
  devinMessagesToEvents,
  devinToolName,
  isDevinTurnEnd,
  lastDevinTurnText,
  reshapeMessage,
  windowDevinMessages,
  type DvMessage,
} from './normalizer.js'

/**
 * Fixtures are the real rows captured from `devin 3000.2.17` session `classy-tourmaline`
 * (`~/.local/share/devin/cli/sessions.db`, `message_nodes`) — two turns, the second calling `exec`.
 */
function msg(over: Partial<DvMessage> & Pick<DvMessage, 'rowId' | 'messageId' | 'role'>): DvMessage {
  return {
    content: '',
    thinking: null,
    toolCalls: null,
    toolCallId: null,
    finishReason: null,
    ...over,
  }
}

const USER_1 = msg({
  rowId: 37,
  messageId: '634a2f5b-42af-4102-8986-6bb16e99a381',
  role: 'user',
  content: 'Reply with exactly DEVIN-PROBE-OK and nothing else.',
})
const ASSISTANT_1 = msg({
  rowId: 58,
  messageId: 'a1a1a1a1-0000-4000-8000-000000000001',
  role: 'assistant',
  content: 'DEVIN-PROBE-OK',
  thinking: 'The user is asking me to reply with exactly "DEVIN-PROBE-OK" and nothing else.',
  finishReason: 'stop',
})
const USER_2 = msg({
  rowId: 60,
  messageId: 'b2b2b2b2-0000-4000-8000-000000000002',
  role: 'user',
  content: 'Run the shell command: echo hello-devin. Then say DEVIN-TOOL-OK.',
})
const ASSISTANT_TOOL = msg({
  rowId: 61,
  messageId: 'c3c3c3c3-0000-4000-8000-000000000003',
  role: 'assistant',
  content: '',
  thinking: 'The user wants me to run a simple shell command `echo hello-devin`.',
  toolCalls: JSON.stringify([
    { id: 'call_d022d4a199c04d298861d6c7', name: 'exec', arguments: { command: 'echo hello-devin' }, index: 0, kind: 'function' },
  ]),
  finishReason: 'tool_calls',
})
const TOOL_RESULT = msg({
  rowId: 63,
  messageId: 'd4d4d4d4-0000-4000-8000-000000000004',
  role: 'tool',
  content: 'Output from command in shell f8215f:\nhello-devin\n\n\nExit code: 0',
  toolCallId: 'call_d022d4a199c04d298861d6c7',
})
const ASSISTANT_2 = msg({
  rowId: 64,
  messageId: 'e5e5e5e5-0000-4000-8000-000000000005',
  role: 'assistant',
  content: 'DEVIN-TOOL-OK',
  thinking: 'The command executed successfully and output "hello-devin".',
  finishReason: 'stop',
})
const SESSION = [USER_1, ASSISTANT_1, USER_2, ASSISTANT_TOOL, TOOL_RESULT, ASSISTANT_2]

function liveTypes(messages: DvMessage[]): string[] {
  const state = newTurnState()
  return messages.flatMap((m) => devinMessageToEvents(m, state)).map((e) => e.type)
}

describe('devin normalizer', () => {
  it('emits a full turn lifecycle for a tool-calling turn', () => {
    const types = liveTypes([USER_2, ASSISTANT_TOOL, TOOL_RESULT, ASSISTANT_2])

    expect(types[0]).toBe('turn_started')
    expect(types).toContain('thinking_delta')
    expect(types).toContain('tool_start')
    expect(types).toContain('tool_end')
    expect(types).toContain('text_delta')
    expect(types[types.length - 1]).toBe('turn_ended')
  })

  it('keeps the turn open while the assistant is still calling tools', () => {
    const state = newTurnState()
    devinMessageToEvents(USER_2, state)
    devinMessageToEvents(ASSISTANT_TOOL, state)

    expect(state.turnOpen).toBe(true)
    expect(isDevinTurnEnd(ASSISTANT_TOOL)).toBe(false)

    devinMessageToEvents(TOOL_RESULT, state)
    devinMessageToEvents(ASSISTANT_2, state)
    expect(state.turnOpen).toBe(false)
    expect(isDevinTurnEnd(ASSISTANT_2)).toBe(true)
  })

  it('maps Devin tool ids onto the shared card vocabulary', () => {
    expect(devinToolName('exec')).toBe('Bash')
    expect(devinToolName('find_file_by_name')).toBe('Glob')
    expect(devinToolName('notebook_edit')).toBe('Edit')
    expect(devinToolName('run_subagent')).toBe('Task')
    expect(devinToolName('webfetch')).toBe('WebFetch')
    // Unmapped tools still read well on a card.
    expect(devinToolName('mcp_call_tool')).toBe('McpCallTool')
    expect(devinToolName('')).toBe('tool')
  })

  it('renders the tool card with the mapped name and its real output', () => {
    const events = devinMessagesToEvents(SESSION)
    const start = events.find((e) => e.type === 'tool_start')
    const end = events.find((e) => e.type === 'tool_end')

    expect((start?.payload as { tool?: string })?.tool).toBe('Bash')
    expect((start?.payload as { input?: { command?: string } })?.input?.command).toBe('echo hello-devin')
    expect((end?.payload as { tool?: string })?.tool).toBe('Bash')
    expect(String((end?.payload as { output?: unknown })?.output)).toContain('hello-devin')
    expect((end?.payload as { isError?: boolean })?.isError).toBe(false)
  })

  it('drops the system prefix and a tool row with no tool_call_id', () => {
    expect(reshapeMessage(msg({ rowId: 1, messageId: 's', role: 'system', content: 'You are Devin' }))).toBeNull()
    expect(reshapeMessage(msg({ rowId: 2, messageId: 't', role: 'tool', content: 'orphan' }))).toBeNull()
  })

  it('takes the last user prompt and the assistant text that followed it as the recap source', () => {
    expect(lastDevinTurnText(SESSION)).toEqual({
      userMessage: 'Run the shell command: echo hello-devin. Then say DEVIN-TOOL-OK.',
      assistantText: 'DEVIN-TOOL-OK',
    })
  })

  it('snaps a pagination window back to a user prompt so a turn is never split', () => {
    // limit=3 would start mid-turn (at ASSISTANT_TOOL); the window must back up to USER_2.
    const w = windowDevinMessages(SESSION, { limit: 3 })

    expect(w.window[0]).toBe(USER_2)
    expect(w.oldestCursor).toBe('devin:2')
    expect(w.hasMore).toBe(true)
  })

  it('rejects a malformed or out-of-range window cursor', () => {
    expect(windowDevinMessages(SESSION, { limit: 2, before: 'hermes:1' }).staleCursor).toBe(true)
    expect(windowDevinMessages(SESSION, { limit: 2, before: 'devin:999' }).staleCursor).toBe(true)
  })

  it('survives malformed tool_calls JSON without dropping the message', () => {
    const broken = msg({
      rowId: 70, messageId: 'f6', role: 'assistant', content: 'still here',
      toolCalls: '{not json', finishReason: 'stop',
    })
    const events = devinMessagesToEvents([USER_1, broken])

    expect(events.some((e) => e.type === 'text_delta')).toBe(true)
    expect(events.some((e) => e.type === 'tool_start')).toBe(false)
  })
})