@recombine-ai/bosun 0.8.3 → 0.9.0

package/src/backend/tests/emulate-agents.ts

@@ -1,11 +1,6 @@
-import {
-	createContext,
-	type Message,
-	type StepTracer,
-	type Logger,
-	type TestAgent,
-	type TestVoiceAgent
-} from '@recombine-ai/engine'
+import { createContext, type Message, type Logger, type Scheduler } from '@recombine-ai/engine'
+import { type TestAgent, type TestVoiceAgent } from '@recombine-ai/bosun-lib'
+import { type StepTracer } from '@recombine-ai/telescope'
 import { getAgentFactories } from '../lib/get-agent-factories'
 import { getImportNonce } from '../lib/import-nonce'
 import { getRootPath } from '../lib/get-root-path'
@@ -17,8 +12,7 @@ export async function loadAgents(props: {
 	sendMessage: (message: Message | string) => Promise<void>
 	stepTracer: StepTracer
 	logger?: Logger
-	context?: Record<string, any>
-	timeoutSeconds: number
+	context?: Record<string, unknown>
 	abortSignal?: AbortSignal
 }): Promise<void> {
 	const {
@@ -29,7 +23,6 @@ export async function loadAgents(props: {
 		stepTracer: stepTracer,
 		logger: providedLogger,
 		context,
-		timeoutSeconds,
 		abortSignal
 	} = props
 	const importNonce = getImportNonce()
@@ -44,34 +37,20 @@ export async function loadAgents(props: {
 		error: () => {},
 		warn: () => {}
 	}
-	const scheduler = {
+	const scheduler: Scheduler = {
 		clearAllPendingActions: async () => {},
-		registerAction: () => async () => {},
-		triggerAction: async () => {},
-		serialize: () => ({}) as any,
-		setState: (_: any) => {}
-	}
-	const ctx = createContext({})
-
-	// Maintain in-run history so sendMessage appends to it, mirroring backend behavior
-	const history = getMessages()
-	const getMessagesWithHistory = () => history
-	const sendMessageWithHistory = async (message: Message | string) => {
-		const m =
-			typeof message === 'string' ? ({ sender: 'agent', text: message } as Message) : message
-		try {
-			history.push(m)
-		} catch {
-			// Best-effort: if history is immutable, ignore push errors
-			logger.log('Failed to push message to history:', m)
-		}
-		await sendMessage(m)
+		registerAction: () => async () => {}
 	}
 
 	const stepRegistry = {
 		addStep: () => {}
 	}
 
+	const ctx = createContext({})
+
+	// Maintain in-run history so sendMessage appends to it, mirroring backend behavior
+	let history: Message[] = []
+
 	if (region) {
 		// The UI-selected region is stored in Bosun's runtime ctx and consumed by the project's workflows.
 		// Setting it before calling the factory ensures region-scoped config/strings are used for this run.
@@ -82,13 +61,25 @@ export async function loadAgents(props: {
 	const agent = await factory({
 		stepTracer: stepTracer,
 		stepRegistry,
-		tracer: stepRegistry,
 		logger: logger,
-		scheduler: scheduler as any,
-		getMessages: getMessagesWithHistory,
-		sendMessage: sendMessageWithHistory,
-		sendAction: async () => {},
-		ctx
+		scheduler: scheduler,
+		getMessages: () => history,
+		async sendMessage(message) {
+			const m =
+				typeof message === 'string' ? ({ sender: 'agent', text: message } as Message) : message
+			try {
+				history.push(m)
+			} catch {
+				// Best-effort: if history is immutable, ignore push errors
+				logger.log('Failed to push message to history:', m)
+			}
+			await sendMessage(m)
+		},
+		ctx,
+		config: {
+			isTest: true,
+			enableTimers: false
+		}
 	})
 
 	if (context && typeof context === 'object') {
@@ -100,7 +91,42 @@ export async function loadAgents(props: {
 		console.error('UNHANDLED', r)
 	})
 
-	const withAbort = async <T>(p: Promise<T>): Promise<T> => {
+	const withAbort = wrapAbort(abortSignal)
+
+	process.env.IS_TEST = 'true'
+	try {
+		if (isVoiceAgent(agent)) {
+			// preparation
+			history = []
+			await withAbort(agent.onCallStart())
+			await withAbort(agent.waitForIdle())
+
+			// actual test
+			history = getMessages()
+			await withAbort(agent.streamResponse())
+			await withAbort(agent.waitForIdle())
+		} else {
+			await withAbort(agent.start())
+			await withAbort(agent.respondToMessage())
+		}
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err))
+		try {
+			logger.error('Error in agent.respondToMessage():', error.message)
+			if (error.stack) logger.error(error.stack)
+		} catch {
+			/* noop */
+		}
+	}
+	process.env.IS_TEST = undefined
+}
+
+function isVoiceAgent(agent: TestAgent): agent is TestVoiceAgent {
+	return 'streamResponse' in agent
+}
+
+function wrapAbort(abortSignal: AbortSignal | undefined) {
+	return async <T>(p: Promise<T>): Promise<T> => {
 		if (!abortSignal) return p
 		if (abortSignal.aborted) throw new Error('Operation cancelled')
 		return await new Promise<T>((resolve, reject) => {
@@ -127,41 +153,9 @@ export async function loadAgents(props: {
 				},
 				(e) => {
 					cleanup()
-					reject(e)
+					reject(e as Error)
 				}
 			)
 		})
 	}
-
-	try {
-		// Some project workflows (e.g. voice) persist required per-run state (like region) during `start()`.
-		await withAbort(
-			Promise.resolve().then(() => (isVoiceAgent(agent) ? agent.onCallStart() : agent.start()))
-		)
-		if (isVoiceAgent(agent)) {
-			await withAbort(agent.streamResponse())
-		} else {
-			await withAbort(agent.respondToMessage())
-		}
-		await withAbort(new Promise((resolve) => setTimeout(resolve, timeoutSeconds * 1000)))
-	} catch (err) {
-		const msg = err instanceof Error ? `${err.name}: ${err.message}` : String(err)
-		const stack = err instanceof Error ? err.stack : undefined
-		try {
-			logger.error('Error in agent.respondToMessage():', msg)
-		} catch {
-			/* noop */
-		}
-		if (stack) {
-			try {
-				logger.error(stack)
-			} catch {
-				/* noop */
-			}
-		}
-	}
-}
-
-function isVoiceAgent(agent: TestAgent): agent is TestVoiceAgent {
-	return 'streamResponse' in agent
 }

package/build/client/_app/immutable/entry/start.gcze8Gig.js

@@ -1 +0,0 @@
-import{l as o,a as r}from"../chunks/yPd1epTY.js";export{o as load_css,r as start};

package/build/client/_app/immutable/entry/start.gcze8Gig.js.br

@@ -1,2 +0,0 @@
-)�import{l as o,a as r}from"../chunks/yPd1epTY.js";export{o as load_css,r as start};
-