@recombine-ai/bosun 0.16.1 → 0.16.2-cloud-2

package/src/backend/tests/router.ts

@@ -1,301 +0,0 @@
-import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import'
-import { z } from 'zod'
-
-import {
-	addTest,
-	deleteTest,
-	getResultEntry,
-	getRunHistory,
-	listRunHistory,
-	loadLatestResultsByTest,
-	loadTests,
-	patchTest,
-	patchTestsBatch,
-	reorderTests
-} from './data'
-import { readSuite, TestRowSchema } from './suite'
-import { cancelPromptTests, getPromptTestsProgress, runPromptTestsManaged } from './academy'
-import { analyzeRunQuotes } from './analyze'
-import { findPromptIssues } from './prompt-issues'
-import type { TrpcContext } from '../lib/trpc-context'
-import { getProjectBosunApi } from '../lib/project-api'
-import {
-	TraceTestReviewContentSchema,
-	TraceTestSeedSchema
-} from '../../lib/tests/pii-sanitized-test-draft'
-import {
-	createPIISanitizedTestDraft,
-	createTestFromPIISanitizedTestDraft
-} from './pii-sanitized-test-drafts'
-import { PIISanitizerResponseError } from './pii-sanitizer'
-
-type SuiteSelection = {
-	suiteKey: string
-	agentId: string
-	region?: string
-}
-
-async function resolveSuiteSelection(
-	agentId: string,
-	region?: string | null
-): Promise<SuiteSelection> {
-	// Convention:
-	// - `agentId` is the canonical factory key (workflow export key).
-	// - `suiteKey` is the filesystem/report key:
-	//    - non-regional projects: `${agentId}`
-	//    - regional projects: `${agentId}.${region}`
-	const bosunApi = await getProjectBosunApi()
-	const meta = bosunApi ? await bosunApi.getAgentMeta(agentId) : null
-	const isRegionScoped = meta?.testScope === 'region'
-	if (!isRegionScoped) return { suiteKey: agentId, agentId }
-
-	if (!bosunApi) {
-		throw new Error(`Project does not export bosunApi, cannot resolve suite for '${agentId}'.`)
-	}
-
-	const resolved = await bosunApi.resolveTestSuite({ agentId, region })
-	return {
-		suiteKey: resolved.suiteKey,
-		agentId,
-		region: resolved.resolvedRegion ?? undefined
-	}
-}
-
-export function createTestsRouter(t: TRPCRootObject<TrpcContext, any, any>) {
-	return t.router({
-		list: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return loadTests(suiteKey)
-			}),
-		latestResult: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return loadLatestResultsByTest(suiteKey)
-			}),
-		runProgress: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return getPromptTestsProgress(suiteKey)
-			}),
-		historyList: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return listRunHistory(suiteKey)
-			}),
-		historyRun: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					timestamp: z.string()
-				})
-			)
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return getRunHistory(suiteKey, input.timestamp)
-			}),
-		resultEntry: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					testId: z.string(),
-					// TODO resultKey should be keyof of ResultEntry
-					resultKey: z.string(),
-					index: z.number().optional(),
-					timestamp: z.string().optional()
-				})
-			)
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return getResultEntry(
-					suiteKey,
-					input.testId,
-					input.resultKey as any,
-					input.index,
-					input.timestamp
-				)
-			}),
-		analyzeRun: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					testId: z.string(),
-					index: z.number().int().nonnegative(),
-					timestamp: z.string().optional()
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return analyzeRunQuotes({
-					agent: suiteKey,
-					testId: input.testId,
-					index: input.index,
-					timestamp: input.timestamp
-				})
-			}),
-		findPromptIssues: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					step: z.string(),
-					prompt: z.string()
-				})
-			)
-			.mutation(async ({ input }) => {
-				return findPromptIssues(input)
-			}),
-		suite: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.query(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return readSuite(suiteKey)
-			}),
-		addTest: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					seed: TestRowSchema.omit({ id: true, order: true }).partial()
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return addTest(suiteKey, input.seed)
-			}),
-		createPIISanitizedTestDraft: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					seed: TraceTestSeedSchema
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				try {
-					const draft = await createPIISanitizedTestDraft({ suiteKey, seed: input.seed })
-					return { status: 'ready' as const, ...draft }
-				} catch (error) {
-					if (!(error instanceof PIISanitizerResponseError)) throw error
-					return {
-						status: 'sanitizer-error' as const,
-						message: error.message,
-						aiResponse: error.aiResponse
-					}
-				}
-			}),
-		createTestFromPIISanitizedTestDraft: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					draftId: z.string().uuid(),
-					reviewed: TraceTestReviewContentSchema
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return createTestFromPIISanitizedTestDraft({
-					suiteKey,
-					draftId: input.draftId,
-					reviewed: input.reviewed
-				})
-			}),
-		patchTest: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					id: z.string(),
-					patch: TestRowSchema.omit({ id: true, order: true }).partial()
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return patchTest(suiteKey, input.id, input.patch)
-			}),
-		patchTestsBatch: t.procedure
-			.input(
-				z.object({
-					agent: z.string(),
-					region: z.string().nullish(),
-					updates: z.array(
-						z.object({
-							id: z.string(),
-							patch: TestRowSchema.omit({ id: true, order: true }).partial()
-						})
-					)
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return patchTestsBatch(suiteKey, input.updates)
-			}),
-		deleteTest: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish(), id: z.string() }))
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return deleteTest(suiteKey, input.id)
-			}),
-		reorder: t.procedure
-			.input(
-				z.object({ agent: z.string(), region: z.string().nullish(), order: z.array(z.string()) })
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return reorderTests(suiteKey, input.order)
-			}),
-		runTests: t.procedure
-			.input(
-				z.union([
-					z
-						.object({
-							agent: z.string(),
-							region: z.string().nullish(),
-							step: z.string(),
-							scope: z.enum(['pinned', 'all']).optional(),
-							repeats: z.number().int().min(1).max(500),
-							concurrency: z.number().int().min(1).max(75)
-						})
-						.strict(),
-					z
-						.object({
-							agent: z.string(),
-							region: z.string().nullish(),
-							testId: z.string(),
-							repeats: z.number().int().min(1).max(500),
-							concurrency: z.number().int().min(1).max(75)
-						})
-						.strict()
-				])
-			)
-			.mutation(async ({ input }) => {
-				const selection = await resolveSuiteSelection(input.agent, input.region)
-				const runConfig = { repeats: input.repeats, concurrency: input.concurrency }
-				if ('testId' in input) {
-					return runPromptTestsManaged(selection, { testId: input.testId }, runConfig)
-				}
-				return runPromptTestsManaged(
-					selection,
-					{
-						scope: input.scope ?? 'pinned',
-						step: input.step
-					},
-					runConfig
-				)
-			}),
-		cancelRun: t.procedure
-			.input(z.object({ agent: z.string(), region: z.string().nullish() }))
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agent, input.region)
-				return cancelPromptTests(suiteKey)
-			})
-	})
-}

package/src/backend/tests/suite.spec.ts

@@ -1,122 +0,0 @@
-import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-const project = vi.hoisted(() => ({ basePath: '', rootPath: '' }))
-
-vi.mock('../lib/project-api', () => ({ getProjectBasePath: async () => project.basePath }))
-vi.mock('../lib/get-root-path', () => ({ getRootPath: async () => project.rootPath }))
-
-import { LEGACY_TEST_SUITE_ERROR_PREFIX, readSuite, writeSuite, type TestRow } from './suite'
-
-const temporaryDirectories: string[] = []
-
-afterEach(async () => {
-	await Promise.all(temporaryDirectories.splice(0).map((dir) => rm(dir, { recursive: true })))
-})
-
-function row(id: string, order: number): TestRow {
-	return {
-		id,
-		order,
-		pinned: 'TRUE',
-		scenario: id,
-		step: 'main',
-		author: '',
-		category: '',
-		assertion_type: 'llm-rubric',
-		assertion_value: '',
-		conversation: 'User: hello',
-		expected_output: 'Hello',
-		evaluation_mode: 'assertion',
-		context_mode: 'merge',
-		timeout: '0',
-		similarity_threshold: '50',
-		context: {}
-	}
-}
-
-async function makeSuite(suiteKey = 'agent') {
-	const dir = await mkdtemp(path.join(os.tmpdir(), 'bosun-yaml-suite-'))
-	temporaryDirectories.push(dir)
-	project.basePath = path.join(dir, 'agents')
-	project.rootPath = path.join(dir, 'bosun', 'workflows.ts')
-	const suiteDirectory = path.join(project.basePath, 'support', 'bosun-tests', suiteKey)
-	await mkdir(suiteDirectory, { recursive: true })
-	return suiteDirectory
-}
-
-describe('YAML test suites', () => {
-	it('defaults JSON comparisons to case-insensitive and persists an enabled override', async () => {
-		const suiteDirectory = await makeSuite()
-		await writeFile(
-			path.join(suiteDirectory, 'json-case.yaml'),
-			'order: 0\npinned: "TRUE"\nscenario: json case\nassertion_type: llm-rubric\nassertion_value: ""\nconversation: ""\nexpected_output: "{}"\nevaluation_mode: json-deep-equal\ntimeout: "0"\nsimilarity_threshold: "50"\ncontext: {}\n'
-		)
-
-		const loaded = await readSuite('agent')
-		expect(loaded.tests[0].case_sensitive).toBe(false)
-
-		await writeSuite('agent', {
-			tests: [{ ...loaded.tests[0], case_sensitive: true }]
-		})
-
-		expect((await readSuite('agent')).tests[0].case_sensitive).toBe(true)
-		expect(await readFile(path.join(suiteDirectory, 'json-case.yaml'), 'utf8')).toContain(
-			'case_sensitive: true'
-		)
-	})
-
-	it('uses file names as ids and sorts tests by their stored order', async () => {
-		const suiteDirectory = await makeSuite()
-		await writeFile(
-			path.join(suiteDirectory, 'second.yaml'),
-			'order: 1024\npinned: "TRUE"\nscenario: second\nassertion_type: llm-rubric\nassertion_value: ""\nconversation: ""\nexpected_output: ""\ntimeout: "0"\nsimilarity_threshold: "50"\ncontext: {}\n'
-		)
-		await writeFile(
-			path.join(suiteDirectory, 'first.yaml'),
-			'order: 0\npinned: "TRUE"\nscenario: first\nassertion_type: llm-rubric\nassertion_value: ""\nconversation: ""\nexpected_output: ""\ntimeout: "0"\nsimilarity_threshold: "50"\ncontext: {}\n'
-		)
-
-		const suite = await readSuite('agent')
-
-		expect(suite.tests.map((test) => test.id)).toEqual(['first', 'second'])
-	})
-
-	it('adds and edits independent files and deletes removed tests', async () => {
-		const suiteDirectory = await makeSuite()
-		await writeSuite('agent', { tests: [row('one', 0), row('two', 1024)] })
-		const twoBefore = await readFile(path.join(suiteDirectory, 'two.yaml'), 'utf8')
-
-		await writeSuite('agent', {
-			tests: [{ ...row('one', 0), scenario: 'edited' }, row('two', 1024), row('three', 2048)]
-		})
-
-		expect(await readFile(path.join(suiteDirectory, 'two.yaml'), 'utf8')).toBe(twoBefore)
-		expect((await readdir(suiteDirectory)).sort()).toEqual(['one.yaml', 'three.yaml', 'two.yaml'])
-
-		await writeSuite('agent', { tests: [row('two', 1024), row('three', 2048)] })
-		expect((await readdir(suiteDirectory)).sort()).toEqual(['three.yaml', 'two.yaml'])
-	})
-
-	it.each(['tests.jsonl', 'tests.json', 'config.json'])(
-		'reports that a legacy %s suite requires migration',
-		async (suffix) => {
-			const dir = await mkdtemp(path.join(os.tmpdir(), 'bosun-legacy-suite-'))
-			temporaryDirectories.push(dir)
-			project.basePath = path.join(dir, 'agents')
-			project.rootPath = path.join(dir, 'bosun', 'workflows.ts')
-			await mkdir(project.basePath, { recursive: true })
-			await mkdir(path.dirname(project.rootPath), { recursive: true })
-			await mkdir(path.join(project.basePath, 'support', 'bosun-tests', 'agent'), {
-				recursive: true
-			})
-			const legacyPath = path.join(path.dirname(project.rootPath), `agent.${suffix}`)
-			await writeFile(legacyPath, '{}\n')
-
-			await expect(readSuite('agent')).rejects.toThrow(LEGACY_TEST_SUITE_ERROR_PREFIX)
-			expect(await readFile(legacyPath, 'utf8')).toBe('{}\n')
-		}
-	)
-})

package/src/backend/tests/suite.ts

@@ -1,236 +0,0 @@
-import { access, mkdir, readFile, readdir, rename, unlink, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { dump, load } from 'js-yaml'
-import { z } from 'zod'
-
-import { getRootPath } from '../lib/get-root-path'
-import { getProjectBasePath } from '../lib/project-api'
-
-export const LEGACY_TEST_SUITE_ERROR_PREFIX = 'BOSUN_LEGACY_TEST_SUITE:'
-
-export const TestRowSchema = z.object({
-	id: z.string(),
-	order: z.number(),
-	pinned: z.enum(['TRUE', 'FALSE']),
-	scenario: z.string(),
-	step: z.string().optional(),
-	author: z.string().optional(),
-	category: z.string().optional(),
-	assertion_type: z.string(),
-	assertion_value: z.string(),
-	conversation: z.string(),
-	expected_output: z.string(),
-	evaluation_mode: z.enum(['assertion', 'json-deep-equal']).optional(),
-	case_sensitive: z.boolean().optional(),
-	context_mode: z.enum(['merge', 'replace']).optional(),
-	timeout: z.string(),
-	similarity_threshold: z.string(),
-	context: z.record(z.unknown()),
-	mocks: z.record(z.unknown()).optional()
-})
-
-const StoredTestSchema = TestRowSchema.omit({ id: true })
-
-export const TestSuiteSchema = z.object({
-	tests: z.array(TestRowSchema)
-})
-
-export type TestRow = z.infer<typeof TestRowSchema>
-export type TestSuite = z.infer<typeof TestSuiteSchema>
-
-const suiteMutationQueue = new Map<string, Promise<void>>()
-
-async function exists(targetPath: string): Promise<boolean> {
-	try {
-		await access(targetPath)
-		return true
-	} catch {
-		return false
-	}
-}
-
-async function getLegacySuiteFiles(suiteKey: string): Promise<string[]> {
-	const legacyDirectory = path.dirname(await getRootPath())
-	const candidates = [
-		path.join(legacyDirectory, `${suiteKey}.tests.jsonl`),
-		path.join(legacyDirectory, `${suiteKey}.tests.json`),
-		path.join(legacyDirectory, `${suiteKey}.config.json`)
-	]
-	const matches = await Promise.all(
-		candidates.map(async (candidate) => ((await exists(candidate)) ? candidate : null))
-	)
-	return matches.filter((candidate): candidate is string => candidate !== null)
-}
-
-function legacySuiteError(suiteKey: string, files: string[]): Error {
-	return new Error(
-		`${LEGACY_TEST_SUITE_ERROR_PREFIX} Test suite '${suiteKey}' uses the unsupported JSON/JSONL format. ` +
-			`Migrate it to per-test YAML files before using this version of Bosun. Legacy files: ${files.join(', ')}`
-	)
-}
-
-export async function getSuiteDirectory(suiteKey: string): Promise<string> {
-	if (!suiteKey || path.basename(suiteKey) !== suiteKey || suiteKey === '.' || suiteKey === '..') {
-		throw new Error(`Invalid test suite key: '${suiteKey}'`)
-	}
-
-	const legacyFiles = await getLegacySuiteFiles(suiteKey)
-	if (legacyFiles.length > 0) throw legacySuiteError(suiteKey, legacyFiles)
-
-	const agentsPath = await getProjectBasePath()
-	const entries = await readdir(agentsPath, { withFileTypes: true })
-	const matches: string[] = []
-
-	for (const entry of entries) {
-		if (!entry.isDirectory()) continue
-		const candidate = path.join(agentsPath, entry.name, 'bosun-tests', suiteKey)
-		if (await exists(candidate)) matches.push(candidate)
-	}
-
-	if (matches.length === 0) {
-		throw new Error(
-			`Test suite '${suiteKey}' was not found under ${agentsPath}/*/bosun-tests/${suiteKey}`
-		)
-	}
-	if (matches.length > 1) {
-		throw new Error(
-			`Test suite '${suiteKey}' exists in multiple agent directories: ${matches.join(', ')}`
-		)
-	}
-	return matches[0]
-}
-
-export async function withSuiteMutationLock<T>(suiteKey: string, fn: () => Promise<T>): Promise<T> {
-	const previous = suiteMutationQueue.get(suiteKey) ?? Promise.resolve()
-	let release!: () => void
-	const gate = new Promise<void>((resolve) => {
-		release = resolve
-	})
-	const queued = previous.catch(() => {}).then(() => gate)
-	suiteMutationQueue.set(suiteKey, queued)
-
-	await previous.catch(() => {})
-
-	try {
-		return await fn()
-	} finally {
-		release()
-		if (suiteMutationQueue.get(suiteKey) === queued) {
-			suiteMutationQueue.delete(suiteKey)
-		}
-	}
-}
-
-function testFileName(id: string): string {
-	if (!id || path.basename(id) !== id || id === '.' || id === '..') {
-		throw new Error(`Invalid test id for a file name: '${id}'`)
-	}
-	return `${id}.yaml`
-}
-
-export async function readSuite(suiteKey: string): Promise<TestSuite> {
-	const suiteDirectory = await getSuiteDirectory(suiteKey)
-	const files = (await readdir(suiteDirectory, { withFileTypes: true }))
-		.filter(
-			(entry) => entry.isFile() && entry.name.endsWith('.yaml') && !entry.name.startsWith('.')
-		)
-		.map((entry) => entry.name)
-	const rows = await Promise.all(
-		files.map(async (fileName) => {
-			const id = fileName.slice(0, -'.yaml'.length)
-			try {
-				const parsed = load(await readFile(path.join(suiteDirectory, fileName), 'utf8'))
-				return normalizeRow({ id, ...StoredTestSchema.parse(parsed) })
-			} catch (error) {
-				throw new Error(`Error loading test '${id}' from ${path.join(suiteDirectory, fileName)}`, {
-					cause: error
-				})
-			}
-		})
-	)
-
-	rows.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
-	return { tests: rows }
-}
-
-function serializeRow(row: TestRow): string {
-	const normalized = normalizeRow(row)
-	const { id: _id, ...stored } = normalized
-	return dump(StoredTestSchema.parse(stored), {
-		lineWidth: -1,
-		noRefs: true,
-		noCompatMode: true
-	})
-}
-
-async function writeRow(suiteDirectory: string, row: TestRow): Promise<void> {
-	const destination = path.join(suiteDirectory, testFileName(row.id))
-	const body = serializeRow(row)
-	try {
-		if ((await readFile(destination, 'utf8')) === body) return
-	} catch {
-		// New test.
-	}
-
-	const temporary = path.join(
-		suiteDirectory,
-		`.${path.basename(destination)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
-	)
-	await writeFile(temporary, body, 'utf8')
-	try {
-		await rename(temporary, destination)
-	} catch {
-		try {
-			await unlink(destination)
-		} catch {
-			// Destination did not exist.
-		}
-		await rename(temporary, destination)
-	}
-}
-
-export async function writeSuite(suiteKey: string, suite: TestSuite): Promise<void> {
-	const suiteDirectory = await getSuiteDirectory(suiteKey)
-	await mkdir(suiteDirectory, { recursive: true })
-	const expectedFiles = new Set(suite.tests.map((row) => testFileName(row.id)))
-	const existingFiles = (await readdir(suiteDirectory, { withFileTypes: true }))
-		.filter(
-			(entry) => entry.isFile() && entry.name.endsWith('.yaml') && !entry.name.startsWith('.')
-		)
-		.map((entry) => entry.name)
-
-	await Promise.all(suite.tests.map((row) => writeRow(suiteDirectory, row)))
-	await Promise.all(
-		existingFiles
-			.filter((fileName) => !expectedFiles.has(fileName))
-			.map((fileName) => unlink(path.join(suiteDirectory, fileName)))
-	)
-}
-
-export function normalizeRow(r: any): TestRow {
-	const row: TestRow = {
-		id: String(r.id || ''),
-		order: Number.isFinite(Number(r.order)) ? Number(r.order) : 0,
-		pinned: String(r.pinned || 'TRUE').toUpperCase() === 'TRUE' ? 'TRUE' : 'FALSE',
-		scenario: String(r.scenario || ''),
-		step: String(r.step || 'main'),
-		author: r.author != null ? String(r.author) : '',
-		category: r.category != null ? String(r.category) : '',
-		assertion_type: String(r.assertion_type || 'llm-rubric'),
-		assertion_value: String(r.assertion_value || ''),
-		conversation: String(r.conversation || ''),
-		expected_output: String(r.expected_output || ''),
-		timeout: String(r.timeout ?? '0'),
-		similarity_threshold: String(r.similarity_threshold ?? '50'),
-		context: r.context || {}
-	}
-	if (r.evaluation_mode === 'json-deep-equal') {
-		row.evaluation_mode = 'json-deep-equal'
-		row.case_sensitive = r.case_sensitive === true
-	} else {
-		row.evaluation_mode = 'assertion'
-	}
-	row.context_mode = r.context_mode === 'replace' ? 'replace' : 'merge'
-	if (typeof r.mocks !== 'undefined') row.mocks = r.mocks || {}
-	return row
-}