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

package/src/backend/roleplay/fs-persistence.ts

@@ -1,81 +0,0 @@
-import { type AgentState } from './agents'
-import fs from 'fs'
-import path from 'path'
-import { getProjectDataDir } from '../lib/project-data-dir'
-
-export interface StatePersistence {
-	load: (agentId: string) => Promise<AgentState[]>
-	save: (agentId: string, states: AgentState[]) => Promise<void>
-}
-
-export type Context = Record<string, any>
-
-export interface ContextPersistence {
-	load: (contextName: string) => Promise<Context>
-	save: (contextName: string, context: Context) => Promise<void>
-}
-
-export const fsStatePersistence: StatePersistence = {
-	load: async (agentId: string) => {
-		const filePath = getProjectDataDir('history', `${agentId}.json`)
-		return fsPersistence.load(filePath)
-	},
-	save: async (agentId: string, states: AgentState[]) => {
-		const filePath = getProjectDataDir('history', `${agentId}.json`)
-		return fsPersistence.save(filePath, states)
-	}
-}
-
-export const fsContextPersistence: ContextPersistence = {
-	load: async (contextName: string) => {
-		const filePath = getProjectDataDir('contexts', `${contextName}.json`)
-		return fsPersistence.load(filePath)
-	},
-	save: async (contextName: string, context: Context) => {
-		const filePath = getProjectDataDir('contexts', `${contextName}.json`)
-		return fsPersistence.save(filePath, context)
-	}
-}
-
-const fsPersistence = {
-	load: async (filePath: string) => {
-		try {
-			const data = String(await fs.promises.readFile(filePath))
-			return data ? JSON.parse(data) : ''
-		} catch (error) {
-			if ((error as any).code === 'ENOENT') {
-				await createFileIfNotExists(filePath)
-				return ''
-			}
-			console.error('error loading: ', filePath, String(await fs.promises.readFile(filePath)))
-			throw error
-		}
-	},
-	// TODO replace with JSONObject | JSONArray
-	save: async (filePath: string, toSave: Object) => {
-		await createFileIfNotExists(filePath)
-		await fs.promises.writeFile(filePath, JSON.stringify(toSave, null, 2))
-	}
-}
-
-/**
- * Ensures that a file exists by creating any necessary parent directories and the file itself
- * @param filePath Path to the file, may include nested directories
- */
-async function createFileIfNotExists(filePath: string) {
-	const directory = path.dirname(filePath)
-
-	try {
-		await fs.promises.access(directory)
-	} catch (error) {
-		// Directory doesn't exist, create it recursively
-		await fs.promises.mkdir(directory, { recursive: true })
-	}
-
-	try {
-		await fs.promises.access(filePath)
-	} catch (error) {
-		// File doesn't exist, create an empty file
-		await fs.promises.writeFile(filePath, '')
-	}
-}

package/src/backend/roleplay/logger.ts

@@ -1,30 +0,0 @@
-import { inspect } from 'util'
-import type { LogEntry } from '../../lib/ws-message'
-
-export function createLogger(sendMessage: (msg: LogEntry) => void) {
-	const enableConsole = !!process.env.PRINT_CONSOLE
-	return {
-		log: (...args: any[]) => {
-			if (enableConsole) console.log(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'INFO' })
-		},
-		debug: (...args: any[]) => {
-			if (enableConsole) console.debug(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'DEBUG' })
-		},
-		error: (...args: any[]) => {
-			if (enableConsole) console.error(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'ERROR' })
-		},
-		warn: (...args: any[]) => {
-			if (enableConsole) console.warn(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'WARNING' })
-		}
-	}
-}
-
-function prettyArgs(args: any[]) {
-	return args
-		.map((arg) => (typeof arg === 'object' ? inspect(arg, { depth: null }) : arg))
-		.join(' ')
-}

package/src/backend/roleplay/message-dispatcher.ts

@@ -1,93 +0,0 @@
-import type {
-	DelayedActions,
-	LogEntry,
-	AgentPayload,
-	AgentSateHeader,
-	WsMessage
-} from '../../lib/ws-message'
-
-import {
-	type ApiCallTrace,
-	type StepTrace,
-	type ConversationalTrace
-} from '@recombine-ai/telescope'
-import { WebSocket } from 'ws'
-
-export class MessageDispatcher {
-	constructor(private ws: WebSocket) {}
-
-	private sendWsMessage(message: WsMessage) {
-		if (message.channel === 'app-events') {
-			console.log('<-- ', message.channel, message.event.type)
-		} else if (message.channel === 'step-trace') {
-			console.log('<-- ', message.channel, message.trace?.name)
-		} else if (message.channel === 'api-call-trace') {
-			console.log(
-				'<-- ',
-				message.channel,
-				`${message.trace?.operationName} (${message.trace?.method} ${message.trace?.path})`
-			)
-		} else if (message.channel === 'conversational-trace') {
-			console.log('<-- ', message.channel, `${message.trace?.eventName} (${message.trace?.role})`)
-		}
-		this.ws.send(JSON.stringify(message))
-	}
-
-	sendLog = async (message: LogEntry) => {
-		this.sendWsMessage({ channel: 'log', message })
-	}
-
-	sendTrace = async (trace: StepTrace) => {
-		this.sendWsMessage({ channel: 'step-trace', trace })
-	}
-
-	sendApiCallTrace = async (trace: ApiCallTrace) => {
-		this.sendWsMessage({ channel: 'api-call-trace', trace })
-	}
-
-	sendConversationalTrace = async (trace: ConversationalTrace) => {
-		this.sendWsMessage({ channel: 'conversational-trace', trace })
-	}
-
-	sendSchedule = async (actions: DelayedActions) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'delayed-actions-updated', actions }
-		})
-	}
-
-	sendAgentSelected = async (agent: AgentPayload) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'agent-selected', agent }
-		})
-	}
-
-	sendContext = async (context: Record<string, any>, promptContext: Record<string, any>) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'context-updated', context, promptContext }
-		})
-	}
-
-	sendPrompt = async (prompt: string) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'prompt-updated', prompt }
-		})
-	}
-
-	sendLoaded = async (agents: string[]) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'agents-loaded', agents }
-		})
-	}
-
-	sendUpdateStates = async (states: AgentSateHeader[]) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'update-states', states }
-		})
-	}
-}

package/src/backend/roleplay/old-server.ts

@@ -1,82 +0,0 @@
-import { WebSocket } from 'ws'
-import type { WsMessage } from '../../lib/ws-message'
-import { createAgents } from './agents'
-import { fsContextPersistence, fsStatePersistence } from './fs-persistence'
-import { MessageDispatcher } from './message-dispatcher'
-
-export async function oldServer(ws: WebSocket) {
-	console.log('== Client connected ==')
-
-	const agents = createAgents(new MessageDispatcher(ws), fsStatePersistence, fsContextPersistence)
-
-	await agents.load()
-
-	// Queue websocket message handling so client-side multi-send sequences (e.g. select state -> send chat)
-	// are applied deterministically and don't race when handlers `await`.
-	let messageQueue = Promise.resolve()
-
-	ws.on('message', (event) => {
-		const raw = event.toString()
-
-		messageQueue = messageQueue
-			.then(async () => {
-				let msg: WsMessage
-				try {
-					msg = JSON.parse(raw) as WsMessage
-				} catch (error) {
-					console.error('Error parsing websocket message', error)
-					return
-				}
-
-				// @ts-ignore
-				console.log('--> ', msg.channel, msg.event?.type || '')
-
-				switch (msg.channel) {
-					case 'app-events':
-						switch (msg.event.type) {
-							case 'select-agent':
-								await agents.select(msg.event.agent, msg.event.state, msg.event.region)
-								break
-							case 'reload-project':
-								await agents.reload()
-								break
-							case 'context-updated':
-								await agents.updateContext(msg.event.context)
-								break
-							case 'prompt-updated':
-								await agents.updatePrompt(msg.event.prompt)
-								break
-							case 'trigger-action':
-								await agents.triggerAction(msg.event.action)
-								break
-							case 'step-selected':
-								await agents.selectStep(msg.event.step)
-								break
-							case 'hangup':
-								await agents.hangup(msg.event.agentId, msg.event.region)
-								break
-
-							default:
-								console.error(`Unknown event type: ${msg.event.type}`)
-						}
-						break
-					case 'chat':
-						await agents.handleMessage(msg.message)
-						break
-					default:
-						console.error(`Unknown channel: ${msg.channel}`)
-				}
-			})
-			.catch((error) => {
-				console.error('Error handling message', error)
-				try {
-					ws.send(JSON.stringify({ channel: 'error', message: String(error) }))
-				} catch {}
-			})
-	})
-
-	ws.on('close', async () => {
-		// TODO destroy agents here
-		console.log('=== client disconnected ===')
-	})
-}

package/src/backend/roleplay/router.ts

@@ -1,366 +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 { fsContextPersistence, fsStatePersistence } from './fs-persistence'
-import { validateAndReplaceSchemaFile } from './schema-file'
-import { generateReplyVariants, replaceSavedState } from './variants'
-
-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 persistPromptUpdate(input.agentId, input.step, input.prompt)
-				return { ok: true }
-			}),
-		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(),
-					promptUpdate: z
-						.object({
-							step: z.string().trim().min(1).max(512),
-							prompt: z.string().max(1_000_000)
-						})
-						.nullable()
-						.optional(),
-					count: z.number().int().min(1).max(9).default(9)
-				})
-			)
-			.mutation(async ({ input }) => {
-				if (input.promptUpdate) {
-					await persistPromptUpdate(
-						input.agentId,
-						input.promptUpdate.step,
-						input.promptUpdate.prompt
-					)
-				}
-				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
-				})
-
-				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 []
-	}
-}
-
-const noop = () => void 0
-const noopAsync = () => Promise.resolve()
-
-async function persistPromptUpdate(agentId: string, stepName: string, prompt: string) {
-	const { basePath, steps } = await loadAgentSteps(agentId)
-	const targetStep = steps.find((step) => step?.name === stepName)
-	if (!targetStep || targetStep?.prompt?.type !== 'file') return
-
-	const promptPath = path.resolve(basePath, targetStep.prompt.path)
-	await fs.promises.writeFile(promptPath, prompt, 'utf-8')
-}
-
-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 loadAgentSteps(agentId: string) {
-	const { factory, basePath } = await getAgentFactory(agentId)
-	const ctx = createContext({})
-	const steps: any[] = []
-	const stepRegistry = {
-		addStep: (step: any) => {
-			steps.push(step)
-		},
-		getSteps: () => steps
-	}
-
-	await factory({
-		ctx,
-		getMessages: () => [],
-		logger: console,
-		scheduler: {
-			clearAllPendingActions: noopAsync,
-			registerAction: () => noopAsync
-		},
-		sendMessage: noopAsync,
-		stepRegistry,
-		stepTracer: {
-			addStepTrace: noop,
-			flush: noopAsync
-		},
-		config: {
-			enableTimers: false,
-			isTest: false
-		}
-	})
-
-	return { basePath, steps }
-}
-
-async function getAgentFactory(agentId: string) {
-	const rootPath = await getRootPath()
-	const agentFactories = await getAgentFactories(rootPath)
-	const factory = agentFactories.factories[agentId]
-	if (!factory) {
-		throw new Error(`Cannot find agent ${agentId}`)
-	}
-	return { factory, basePath: agentFactories.basePath }
-}
-
-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()
-}