@recombine-ai/bosun 0.18.0 → 0.20.0

package/src/backend/roleplay/router.ts

@@ -1,468 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { z } from 'zod'
-import { createContext } from '@recombine-ai/engine'
-import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import'
-import { scheduleManagedBackendRestart } from '../lib/backend-restart'
-import { getAgentCatalog, getAgentFactories } from '../lib/get-agent-factories'
-import { bumpImportNonce } from '../lib/import-nonce'
-import { getProjectDataDir } from '../lib/project-data-dir'
-import { getRootPath } from '../lib/get-root-path'
-import type { TrpcContext } from '../lib/trpc-context'
-import { analyzeTraceQuotes, generateSuggestedUserResponse } from '../tests/analyze'
-import type { AgentState } from './agents'
-import { getAgentFactory, loadAgentSteps, noop, noopAsync } from './agent-loader'
-import { fsContextPersistence, fsStatePersistence } from './fs-persistence'
-import { readEditablePrompt, withPromptFileLock } from './prompt-file'
-import { validateAndReplaceSchemaFile } from './schema-file'
-import { generateReplyVariants, replaceSavedState } from './variants'
-import {
-	createPromptEditProposal,
-	deletePromptEditProposal,
-	getPromptEditProposal,
-	getPromptEditProposalForAcceptance
-} from './prompt-edit-proposals'
-import { suggestPromptEdit } from './suggest-prompt-edit'
-import { suggestTestFix } from './suggest-test-fix'
-import { getPromptEditProgress, updatePromptEditProgress } from './prompt-edit-progress'
-import { readSuite, withSuiteMutationLock } from '../tests/suite'
-import { resolveSuiteSelection } from '../tests/test-selection'
-import { testEditSourceFingerprint } from '../tests/test-edit-source'
-import { createTestHistoryEditProposal } from '../tests/test-history-edit-proposals'
-import { assertionLabel as getAssertionLabel } from '../../lib/tests/assertion-types'
-
-const AgentIdSchema = z.string().trim().min(1).max(512)
-const promptMappersCache = new Map<string, (ctx: object) => object>()
-
-export function createRolePlayRouter(t: TRPCRootObject<TrpcContext, any, any>) {
-	return t.router({
-		list: t.procedure.query(async () => {
-			const rootPath = await getRootPath()
-			const project = await getAgentFactories(rootPath)
-			return Object.keys(project.factories)
-		}),
-		catalog: t.procedure.query(async () => {
-			const rootPath = await getRootPath()
-			const project = await getAgentFactories(rootPath)
-			return getAgentCatalog(project)
-		}),
-		analyzeTrace: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					traceId: z.string().trim().min(1).max(2048).optional(),
-					eventName: z.string().trim().min(1).max(256).optional(),
-					createdAt: z.number().finite().optional(),
-					model: z.string().trim().min(1).max(512).optional(),
-					renderedPrompt: z.string(),
-					stringifiedConversation: z.string(),
-					response: z.string(),
-					stepTrace: z.unknown().optional()
-				})
-			)
-			.mutation(async ({ input }) => {
-				return analyzeTraceQuotes({
-					model: input.model,
-					renderedPrompt: input.renderedPrompt,
-					stringifiedConversation: input.stringifiedConversation,
-					response: input.response,
-					stepTrace: input.stepTrace as any,
-					rawInput: {
-						source: 'roleplay',
-						agentId: input.agentId,
-						traceId: input.traceId ?? null,
-						eventName: input.eventName ?? null,
-						createdAt: input.createdAt ?? null
-					}
-				})
-			}),
-		generateUserResponse: t.procedure
-			.input(
-				z.object({
-					model: z.string().trim().min(1).max(2048).optional(),
-					stringifiedConversation: z.string(),
-					response: z.string()
-				})
-			)
-			.mutation(async ({ input }) => {
-				return generateSuggestedUserResponse({
-					model: input.model,
-					stringifiedConversation: input.stringifiedConversation,
-					response: input.response
-				})
-			}),
-		savePrompt: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					step: z.string().trim().min(1).max(512),
-					prompt: z.string().max(1_000_000)
-				})
-			)
-			.mutation(async ({ input }) => {
-				await withPromptFileLock(input.agentId, input.step, (file) => file.write(input.prompt))
-				return { ok: true }
-			}),
-		suggestPromptEdit: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					step: z.string().trim().min(1).max(512),
-					request: z.string().trim().min(1).max(100_000),
-					progressId: z.string().uuid()
-				})
-			)
-			.mutation(async ({ input }) => {
-				const originalPrompt = await readEditablePrompt(input.agentId, input.step)
-				const suggestedPrompt = await suggestPromptEdit({
-					request: input.request,
-					originalPrompt,
-					onProgress: (progress) => updatePromptEditProgress(input.progressId, progress)
-				})
-				if (suggestedPrompt === originalPrompt) return { status: 'unchanged' as const }
-
-				const proposal = createPromptEditProposal({
-					agentId: input.agentId,
-					step: input.step,
-					originalPrompt,
-					suggestedPrompt
-				})
-				return { status: 'changed' as const, proposal }
-			}),
-		suggestTestFix: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					region: z.string().nullish(),
-					testId: z.string(),
-					step: z.string().trim().min(1).max(512),
-					request: z.string().trim().min(1).max(100_000),
-					prompt: z.string().max(1_000_000),
-					basePrompt: z.string().max(1_000_000),
-					currentIncorrectOutcome: z.string().max(1_000_000),
-					progressId: z.string().uuid()
-				})
-			)
-			.mutation(async ({ input }) => {
-				const { suiteKey } = await resolveSuiteSelection(input.agentId, input.region)
-				const test = (await readSuite(suiteKey)).tests.find((row) => row.id === input.testId)
-				if (!test) throw new Error('This test is no longer available.')
-				await withPromptFileLock(input.agentId, input.step, async (file) => {
-					const currentPrompt = await file.read()
-					if (currentPrompt !== input.basePrompt && currentPrompt !== input.prompt) {
-						throw new Error(
-							'The prompt changed before Bosun could start this Fix. Check the prompt, then try again.'
-						)
-					}
-					if (currentPrompt !== input.prompt) await file.write(input.prompt)
-				})
-				const originalPrompt = input.prompt
-				const context = JSON.stringify(test.context ?? {})
-				const assertionLabel =
-					test.evaluation_mode === 'json-deep-equal' ? '' : getAssertionLabel(test.assertion_type)
-				const assertionValue =
-					test.evaluation_mode === 'json-deep-equal' ? '' : test.assertion_value
-				const suggestion = await suggestTestFix({
-					request: input.request,
-					originalPrompt,
-					context,
-					conversation: test.conversation,
-					expectedOutput: test.expected_output,
-					assertionLabel,
-					assertionValue,
-					currentIncorrectOutcome: input.currentIncorrectOutcome,
-					onProgress: (progress) => updatePromptEditProgress(input.progressId, progress)
-				})
-				const originalTestFingerprint = testEditSourceFingerprint(test)
-				const historyTestFingerprint = testEditSourceFingerprint(test, {
-					conversation: suggestion.suggestedConversation
-				})
-				const history =
-					suggestion.suggestedConversation === test.conversation
-						? { status: 'unchanged' as const }
-						: {
-								status: 'changed' as const,
-								proposal: createTestHistoryEditProposal({
-									agentId: input.agentId,
-									region: input.region ?? null,
-									testId: input.testId,
-									step: input.step,
-									originalConversation: test.conversation,
-									suggestedConversation: suggestion.suggestedConversation,
-									expectedOutput: test.expected_output,
-									sourceGuard: {
-										suiteKey,
-										allowedTestFingerprints: [originalTestFingerprint],
-										allowedPromptContents: [originalPrompt, suggestion.suggestedPrompt]
-									}
-								})
-							}
-				const prompt =
-					suggestion.suggestedPrompt === originalPrompt
-						? { status: 'unchanged' as const }
-						: {
-								status: 'changed' as const,
-								proposal: createPromptEditProposal({
-									agentId: input.agentId,
-									step: input.step,
-									originalPrompt,
-									suggestedPrompt: suggestion.suggestedPrompt,
-									testSourceGuard: {
-										suiteKey,
-										testId: input.testId,
-										allowedFingerprints: [originalTestFingerprint, historyTestFingerprint]
-									}
-								})
-							}
-
-				return { history, prompt }
-			}),
-		promptEditProgress: t.procedure
-			.input(z.object({ id: z.string().uuid() }))
-			.query(({ input }) => getPromptEditProgress(input.id)),
-		promptEditProposal: t.procedure
-			.input(z.object({ id: z.string().uuid() }))
-			.query(({ input }) => getPromptEditProposal(input.id)),
-		acceptPromptEdit: t.procedure
-			.input(z.object({ id: z.string().uuid() }))
-			.mutation(async ({ input }) => {
-				const proposal = getPromptEditProposalForAcceptance(input.id)
-				if (!proposal) throw new Error('This prompt suggestion is no longer available')
-				await withPromptFileLock(proposal.agentId, proposal.step, async (file) => {
-					if ((await file.read()) !== proposal.originalPrompt) {
-						throw new Error(
-							'The prompt changed while this suggestion was open. Reject this suggestion, then ask Bosun to create a new one.'
-						)
-					}
-					const guard = proposal.testSourceGuard
-					if (!guard) {
-						await file.write(proposal.suggestedPrompt)
-						return
-					}
-					await withSuiteMutationLock(guard.suiteKey, async () => {
-						const test = (await readSuite(guard.suiteKey)).tests.find(
-							(row) => row.id === guard.testId
-						)
-						if (!test || !guard.allowedFingerprints.includes(testEditSourceFingerprint(test))) {
-							throw new Error(
-								'This test changed while the suggestion was open. Reject this suggestion, then ask Bosun to create a new one.'
-							)
-						}
-						await file.write(proposal.suggestedPrompt)
-					})
-				})
-				deletePromptEditProposal(proposal.id)
-				return { ok: true, prompt: proposal.suggestedPrompt }
-			}),
-		rejectPromptEdit: t.procedure
-			.input(z.object({ id: z.string().uuid() }))
-			.mutation(({ input }) => ({ ok: deletePromptEditProposal(input.id) })),
-		saveSchema: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					step: z.string().trim().min(1).max(512),
-					schema: z.string().max(1_000_000)
-				})
-			)
-			.mutation(async ({ input }) => {
-				await persistSchemaUpdate(input.agentId, input.step, input.schema)
-				bumpImportNonce()
-				return {
-					ok: true,
-					restartScheduled: scheduleManagedBackendRestart()
-				}
-			}),
-		userMessageHistory: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					region: z.string().trim().min(1).max(128).nullable().optional()
-				})
-			)
-			.query(async ({ input }) => {
-				const stateKey = resolveAgentStateKey(input.agentId, input.region ?? null)
-				const filePath = resolveAgentHistoryFile(stateKey)
-				const states = await loadJsonArray(filePath)
-
-				const byText = new Map<string, { text: string; lastSeen: number; uses: number }>()
-				let idx = 0
-
-				for (const state of states) {
-					if (!state || typeof state !== 'object') continue
-					const history = (state as any).history
-					if (!Array.isArray(history)) continue
-
-					for (const entry of history) {
-						if (!entry || typeof entry !== 'object') continue
-						if (entry.type !== 'message') continue
-						const payload = entry.payload
-						if (!payload || typeof payload !== 'object') continue
-						if (payload.sender !== 'user' && payload.sender !== 'system') continue
-
-						const rawText = payload.text
-						if (typeof rawText !== 'string') continue
-						const text = rawText.trim()
-						if (!text) continue
-
-						idx += 1
-						const existing = byText.get(text)
-						if (existing) {
-							existing.lastSeen = idx
-							existing.uses += 1
-						} else {
-							byText.set(text, { text, lastSeen: idx, uses: 1 })
-						}
-					}
-				}
-
-				const items = Array.from(byText.values()).sort((a, b) => b.lastSeen - a.lastSeen)
-				return items.slice(0, 2000)
-			}),
-		generateVariants: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					region: z.string().trim().min(1).max(128).nullable().optional(),
-					context: z.record(z.string(), z.unknown()).nullable().optional(),
-					promptOverrides: z.record(z.string(), z.string().max(1_000_000)).optional(),
-					count: z.number().int().min(1).max(9).default(9)
-				})
-			)
-			.mutation(async ({ input }) => {
-				const stateKey = resolveAgentStateKey(input.agentId, input.region ?? null)
-				const rawStates = await fsStatePersistence.load(stateKey)
-				const states = Array.isArray(rawStates) ? rawStates : []
-				const context =
-					input.context ??
-					(((await fsContextPersistence.load('default')) as Record<string, any> | null) || {})
-
-				const variants = await generateReplyVariants({
-					agentId: input.agentId,
-					region: input.region ?? null,
-					states,
-					count: input.count,
-					context,
-					promptOverrides: input.promptOverrides ?? {}
-				})
-
-				return variants.map((variant, index) => ({
-					id: `variant-${index + 1}`,
-					text: variant.text,
-					state: {
-						history: variant.state.history,
-						schedule: variant.state.schedule
-					}
-				}))
-			}),
-		commitVariant: t.procedure
-			.input(
-				z.object({
-					agentId: AgentIdSchema,
-					region: z.string().trim().min(1).max(128).nullable().optional(),
-					state: z.object({
-						history: z.unknown(),
-						schedule: z.unknown()
-					})
-				})
-			)
-			.mutation(async ({ input }) => {
-				const stateKey = resolveAgentStateKey(input.agentId, input.region ?? null)
-				const rawStates = await fsStatePersistence.load(stateKey)
-				const states = Array.isArray(rawStates) ? rawStates : []
-				const latestState = states.at(-1)
-				if (!latestState) throw new Error('No saved roleplay states found for this agent')
-
-				const nextStates = replaceSavedState(states, latestState.id, {
-					history: input.state.history as AgentState['history'],
-					schedule: input.state.schedule as AgentState['schedule']
-				})
-				await fsStatePersistence.save(stateKey, nextStates)
-				return { ok: true }
-			}),
-		context: t.procedure.input(z.object({ agentId: z.string() })).query(async ({ input }) => {
-			const savedContext = await fsContextPersistence.load('default')
-			if (!savedContext) return {}
-			let mapper = promptMappersCache.get(input.agentId)
-			if (mapper) {
-				return mapper(savedContext)
-			}
-
-			mapper = await getPromptMapper(input.agentId)
-			promptMappersCache.set(input.agentId, mapper)
-			return mapper(savedContext)
-		})
-	})
-}
-
-function resolveAgentStateKey(agentId: string, region: string | null): string {
-	return region ? `${agentId}.${region}` : agentId
-}
-
-function resolveAgentHistoryFile(agentId: string): string {
-	const baseDir = getProjectDataDir('history')
-	const filePath = path.resolve(baseDir, `${agentId}.json`)
-
-	// Prevent path traversal and absolute paths.
-	if (filePath === baseDir || !filePath.startsWith(baseDir + path.sep)) {
-		throw new Error('Invalid agentId')
-	}
-
-	return filePath
-}
-
-async function loadJsonArray(filePath: string): Promise<unknown[]> {
-	try {
-		const raw = await fs.promises.readFile(filePath, 'utf-8')
-		const trimmed = raw.trim()
-		if (!trimmed) return []
-		const parsed = JSON.parse(trimmed) as unknown
-		return Array.isArray(parsed) ? parsed : []
-	} catch (e) {
-		if ((e as any)?.code === 'ENOENT') return []
-		console.error('[roleplay] Failed to load history file:', filePath, e)
-		return []
-	}
-}
-
-async function persistSchemaUpdate(agentId: string, stepName: string, schema: string) {
-	const { basePath, steps } = await loadAgentSteps(agentId)
-	const targetStep = steps.find((step) => step?.name === stepName)
-	if (!targetStep || targetStep?.prompt?.type !== 'file' || !targetStep.schema) {
-		throw new Error(`Step '${stepName}' does not have an editable file schema`)
-	}
-
-	const promptPath = path.resolve(basePath, targetStep.prompt.path)
-	const schemaPath = path.join(path.dirname(promptPath), 'schema.ts')
-	await fs.promises.access(schemaPath)
-	await validateAndReplaceSchemaFile(schemaPath, schema)
-}
-
-async function getPromptMapper(agentId: string) {
-	const { factory } = await getAgentFactory(agentId)
-	const ctx = createContext({})
-	// create noop agent just to get promptContextMapper out of it... ಠ_ಠ
-	await factory({
-		ctx,
-		getMessages: () => [],
-		logger: console,
-		scheduler: {
-			clearAllPendingActions: noopAsync,
-			registerAction: () => noopAsync
-		},
-		sendMessage: noopAsync,
-		stepRegistry: {
-			addStep: () => {}
-		},
-		stepTracer: {
-			addStepTrace: noop,
-			flush: noopAsync
-		},
-		config: {
-			enableTimers: false,
-			isTest: false
-		}
-	})
-
-	return ctx.getPromptContextMapper()
-}

package/src/backend/roleplay/scheduler.ts

@@ -1,76 +0,0 @@
-import type { Logger, Scheduler } from '@recombine-ai/engine'
-import type { DelayedActions } from '../../lib/ws-message'
-
-export type DelayedActionRegistry<T> = Record<
-	string,
-	{ at: string | null; handler: (data: T) => Promise<unknown>; data: T | null }
->
-
-export interface BosunScheduler extends Scheduler {
-	triggerAction: (actionName: string) => Promise<void>
-	serialize: () => DelayedActions
-	setState(state: DelayedActions): void
-}
-
-interface Props {
-	logger: Logger
-	onUpdate: (actions: DelayedActions) => void
-}
-export function createScheduler(
-	{ logger, onUpdate }: Props,
-	delayedActions: DelayedActionRegistry<string> = {}
-) {
-	const scheduler: BosunScheduler = {
-		clearAllPendingActions: async () => {
-			Object.keys(delayedActions).forEach((actionName) => {
-				delayedActions[actionName] = {
-					at: null,
-					handler: delayedActions[actionName].handler,
-					data: null
-				}
-			})
-			console.log('clearAllPendingActions')
-			onUpdate(delayedActions)
-		},
-		registerAction(actionName, handler) {
-			delayedActions[actionName] = { at: null, handler, data: null }
-			// console.log('registerAction', actionName)
-			onUpdate(delayedActions)
-			// TODO should be generic data instead of string phone
-			return async (delay, phone) => {
-				const msg = `Scheduled action "${actionName}" at ${delay.toLocaleString()}`
-				delayedActions[actionName] = { at: delay.toLocaleString(), data: phone, handler }
-				// console.log('registerAction', actionName, delay)
-				onUpdate(delayedActions)
-				logger.log(msg)
-			}
-		},
-		triggerAction: async (actionName: string) => {
-			const action = delayedActions[actionName]
-			if (!action) {
-				logger.error(`Action "${actionName}" not found`)
-				return
-			}
-			const msg = `Triggered action "${actionName}" at ${new Date().toLocaleString()}`
-			logger.log(msg)
-			delayedActions[actionName] = { at: null, handler: action.handler, data: null }
-			console.log('triggerAction', actionName)
-			onUpdate(delayedActions)
-			if (!action.data) {
-				throw new Error('Action data is missing')
-			}
-			await action.handler(action.data)
-		},
-		serialize: () => delayedActions,
-		setState: (state) => {
-			for (const key in state) {
-				const oldSchedule = delayedActions[key]
-				if (oldSchedule) {
-					delayedActions[key] = { ...oldSchedule, ...state[key] }
-				}
-			}
-			onUpdate(delayedActions)
-		}
-	}
-	return scheduler
-}

package/src/backend/roleplay/schema-file.spec.ts

@@ -1,38 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import { validateAndReplaceSchemaFile } from './schema-file'
-
-const tempDirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
-})
-
-describe('validateAndReplaceSchemaFile', () => {
-	it('replaces a schema only after the edited module loads successfully', async () => {
-		const dir = await mkdtemp(path.join(os.tmpdir(), 'bosun-schema-file-'))
-		tempDirs.push(dir)
-		const schemaPath = path.join(dir, 'schema.ts')
-		await writeFile(schemaPath, 'export default { version: 1 }\n', 'utf-8')
-
-		const nextSchema = 'export default { version: 2 }\n'
-		await validateAndReplaceSchemaFile(schemaPath, nextSchema)
-
-		expect(await readFile(schemaPath, 'utf-8')).toBe(nextSchema)
-	})
-
-	it('preserves the existing schema when the edit cannot be loaded', async () => {
-		const dir = await mkdtemp(path.join(os.tmpdir(), 'bosun-schema-file-'))
-		tempDirs.push(dir)
-		const schemaPath = path.join(dir, 'schema.ts')
-		const originalSchema = 'export default { version: 1 }\n'
-		await writeFile(schemaPath, originalSchema, 'utf-8')
-
-		await expect(validateAndReplaceSchemaFile(schemaPath, 'export default {')).rejects.toThrow(
-			'Schema could not be loaded'
-		)
-		expect(await readFile(schemaPath, 'utf-8')).toBe(originalSchema)
-	})
-})

package/src/backend/roleplay/schema-file.ts

@@ -1,33 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-export async function validateAndReplaceSchemaFile(schemaPath: string, schema: string) {
-	const dir = path.dirname(schemaPath)
-	const tempPath = path.join(
-		dir,
-		`.schema.bosun-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.ts`
-	)
-
-	await fs.promises.writeFile(tempPath, schema, 'utf-8')
-	try {
-		const validationUrl = pathToFileURL(tempPath)
-		validationUrl.searchParams.set('bosunSchemaValidation', String(Date.now()))
-		await import(validationUrl.href)
-
-		try {
-			await fs.promises.rename(tempPath, schemaPath)
-		} catch {
-			// Windows does not replace an existing destination atomically. The temporary module has
-			// already loaded successfully, so fall back to a direct write there.
-			await fs.promises.writeFile(schemaPath, schema, 'utf-8')
-			await fs.promises.unlink(tempPath).catch(() => {})
-		}
-	} catch (error) {
-		await fs.promises.unlink(tempPath).catch(() => {})
-		throw new Error(
-			`Schema could not be loaded: ${error instanceof Error ? error.message : String(error)}`,
-			{ cause: error }
-		)
-	}
-}

package/src/backend/roleplay/step-registry.spec.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createStepRegistry } from './step-registry'
-
-describe('createStepRegistry prompt overrides', () => {
-	it('uses an in-memory override without changing the underlying prompt source', async () => {
-		const prompt = {
-			type: 'file' as const,
-			path: 'prompts/main.md',
-			content: async () => 'saved prompt'
-		}
-		const registry = createStepRegistry(console, { main: 'suggested prompt' })
-		registry.addStep({ name: 'main', type: 'text', prompt })
-
-		expect(await prompt.content()).toBe('suggested prompt')
-
-		registry.setPromptOverrides({})
-		expect(await prompt.content()).toBe('saved prompt')
-	})
-})

package/src/backend/roleplay/step-registry.ts

@@ -1,22 +0,0 @@
-import type { Logger, StepDef } from '@recombine-ai/engine'
-
-export type PromptOverrides = Record<string, string>
-
-export function createStepRegistry(logger: Logger, initialOverrides: PromptOverrides = {}) {
-	const steps: StepDef[] = []
-	let promptOverrides = { ...initialOverrides }
-	return {
-		addStep(def: StepDef) {
-			const originalContent = def.prompt.content.bind(def.prompt)
-			def.prompt.content = async () => {
-				const override = promptOverrides[def.name]
-				return typeof override === 'string' ? override : originalContent()
-			}
-			steps.push(def)
-		},
-		getSteps: () => steps,
-		setPromptOverrides(next: PromptOverrides) {
-			promptOverrides = { ...next }
-		}
-	}
-}