@roj-ai/sdk 0.1.26 → 0.1.28

package/src/plugins/services/service.ts

@@ -13,7 +13,7 @@ import { Err, Ok } from '~/lib/utils/result.js'
 import type { FileSystem } from '~/platform/fs.js'
 import type { ChildProcess, ProcessRunner } from '~/platform/process.js'
 import type { PortPool } from '~/plugins/services/port-pool.js'
-import type { ServiceConfig, ServiceStatus } from '~/plugins/services/schema.js'
+import type { ServiceConfig, ServiceStartArgs, ServiceStatus } from '~/plugins/services/schema.js'
 import type { ToolError } from '../../core/tools/executor.js'
 import type { Logger } from '../../lib/logger/logger.js'
 import { RingBuffer } from '../../lib/logger/ring-buffer.js'
@@ -57,9 +57,20 @@ interface RunningService {
 	pid: number
 	status: ServiceStatus
 	port: number
+	cwd?: string
+	command: string
 	logs: RingBuffer
 }
 
+export interface ServiceStatusChangeDetails {
+	port?: number
+	error?: string
+	pid?: number
+	pidStartTime?: number
+	cwd?: string
+	command?: string
+}
+
 /** Matches a port bind-conflict across the Node and Bun runtimes. */
 const PORT_CONFLICT_PATTERN = /EADDRINUSE|address already in use/i
 
@@ -98,10 +109,7 @@ export class ServiceExecutor {
 		sessionId: string,
 		serviceType: string,
 		status: ServiceStatus,
-		port?: number,
-		error?: string,
-		pid?: number,
-		pidStartTime?: number,
+		details: ServiceStatusChangeDetails,
 	) => void
 
 	constructor(logger: Logger, portPool: PortPool, deps: ServiceExecutorDeps) {
@@ -115,14 +123,46 @@ export class ServiceExecutor {
 		sessionId: string,
 		serviceType: string,
 		status: ServiceStatus,
-		port?: number,
-		error?: string,
-		pid?: number,
-		pidStartTime?: number,
+		details: ServiceStatusChangeDetails = {},
 	): void {
-		this.onStatusChanged?.(sessionId, serviceType, status, port, error, pid, pidStartTime)
+		this.onStatusChanged?.(sessionId, serviceType, status, details)
 		if (status === 'ready' || status === 'failed' || status === 'stopped') {
-			this.resolveWaiters(serviceType, status, error)
+			this.resolveWaiters(serviceType, status, details.error)
+		}
+	}
+
+	private async isAvailable(config: ServiceConfig, sessionId: SessionId, workspaceDir?: string): Promise<Result<boolean, ToolError>> {
+		if (!config.availableWhen) return Ok(true)
+
+		try {
+			return Ok(await config.availableWhen({ sessionId: String(sessionId), workspaceDir }))
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error)
+			return Err({ message: `Service '${config.type}' availability check failed: ${message}`, recoverable: true })
+		}
+	}
+
+	private async resolveCwd(config: ServiceConfig, sessionId: SessionId, workspaceDir?: string): Promise<Result<string | undefined, ToolError>> {
+		try {
+			if (typeof config.cwd === 'function') {
+				if (!workspaceDir) {
+					return Err({
+						message: `Service '${config.type}' cwd resolver requires a workspaceDir`,
+						recoverable: true,
+					})
+				}
+				const raw = await config.cwd({ sessionId: String(sessionId), workspaceDir })
+				return Ok(resolve(workspaceDir, raw))
+			}
+
+			if (config.cwd !== undefined) {
+				return Ok(workspaceDir ? resolve(workspaceDir, config.cwd) : resolve(config.cwd))
+			}
+
+			return Ok(workspaceDir)
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error)
+			return Err({ message: `Service '${config.type}' cwd resolver failed: ${message}`, recoverable: true })
 		}
 	}
 
@@ -214,44 +254,74 @@ export class ServiceExecutor {
 			return Ok(undefined)
 		}
 
+		const availability = await this.isAvailable(config, sessionId, workspaceDir)
+		if (!availability.ok) return availability
+		if (!availability.value) {
+			return Err({ message: `Service '${config.type}' is not available in this workspace`, recoverable: true })
+		}
+
 		// Allocate port: reuse session-level allocation, then try preferred, then random
 		let port = this.allocatedPorts.get(config.type)
+		let allocatedNow = false
 		if (port === undefined) {
 			port = this.portPool.allocatePreferred(preferredPort) ?? undefined
 			if (port === undefined) {
-				this.notifyStatusChanged(sessionId, config.type, 'failed', undefined, 'No ports available in pool')
+				this.notifyStatusChanged(sessionId, config.type, 'failed', { error: 'No ports available in pool' })
 				return Err({ message: 'No ports available in pool', recoverable: true })
 			}
 			this.allocatedPorts.set(config.type, port)
+			allocatedNow = true
 		}
 
-		// Resolve cwd: a callback is invoked lazily at start (the workspace is
-		// populated by now), a string is used directly. Either result is resolved
-		// against the workspace dir so a relative path (e.g. 'packages/web' for a
-		// monorepo) lands inside this session's worktree; absolute paths pass through.
-		let cwd = workspaceDir
-		if (config.cwd !== undefined) {
-			const raw = typeof config.cwd === 'function'
-				? await config.cwd({ workspaceDir: workspaceDir ?? process.cwd() })
-				: config.cwd
-			cwd = workspaceDir ? resolve(workspaceDir, raw) : resolve(raw)
+		const cwdResult = await this.resolveCwd(config, sessionId, workspaceDir)
+		if (!cwdResult.ok) {
+			if (allocatedNow) {
+				this.allocatedPorts.delete(config.type)
+				this.portPool.release(port)
+			}
+			this.notifyStatusChanged(sessionId, config.type, 'failed', { port, error: cwdResult.error.message })
+			return cwdResult
 		}
+
+		const cwd = cwdResult.value
 		const logBufferSize = config.logBufferSize ?? 200
 		const startupTimeoutMs = config.startupTimeoutMs ?? 30_000
 
 		const readyRegex = config.readyPattern ? new RegExp(config.readyPattern) : undefined
 
-		// Resolve command: callback gets port, string used as-is
-		const command = typeof config.command === 'function'
-			? config.command({ port })
-			: config.command
+		const startArgs = {
+			port,
+			sessionId: String(sessionId),
+			workspaceDir,
+			cwd,
+		}
+
+		let command: string
+		let serviceEnv: Record<string, string> | undefined
+		try {
+			command = typeof config.command === 'function'
+				? await config.command(startArgs)
+				: config.command
+			serviceEnv = typeof config.env === 'function'
+				? await config.env(startArgs)
+				: config.env
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error)
+			const errorMessage = `Service '${config.type}' start resolver failed: ${message}`
+			if (allocatedNow) {
+				this.allocatedPorts.delete(config.type)
+				this.portPool.release(port)
+			}
+			this.notifyStatusChanged(sessionId, config.type, 'failed', { port, cwd, error: errorMessage })
+			return Err({ message: errorMessage, recoverable: true })
+		}
 
 		const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh'
 		const shellFlag = process.platform === 'win32' ? '/c' : '-c'
 
 		const child = this.processRunner.spawn(shell, [shellFlag, command], {
 			cwd,
-			env: { ...process.env, ...config.env, PORT: String(port) },
+			env: { ...process.env, ...serviceEnv, PORT: String(port) },
 			detached: true,
 			stdio: ['ignore', 'pipe', 'pipe'],
 		})
@@ -263,12 +333,20 @@ export class ServiceExecutor {
 			const current = this.services.get(config.type)
 			if (current && current.process === child && current.status !== 'stopped' && current.status !== 'failed') {
 				current.status = 'failed'
-				this.notifyStatusChanged(sessionId, config.type, 'failed', undefined, error.message)
+				this.notifyStatusChanged(sessionId, config.type, 'failed', {
+					error: error.message,
+					cwd,
+					command,
+				})
 			}
 		})
 
 		if (!child.pid) {
-			this.notifyStatusChanged(sessionId, config.type, 'failed', undefined, 'Failed to spawn process')
+			if (allocatedNow) {
+				this.allocatedPorts.delete(config.type)
+				this.portPool.release(port)
+			}
+			this.notifyStatusChanged(sessionId, config.type, 'failed', { port, cwd, command, error: 'Failed to spawn process' })
 			return Err({ message: 'Failed to spawn service process', recoverable: true })
 		}
 
@@ -276,8 +354,8 @@ export class ServiceExecutor {
 		// "our process" from "an unrelated process that grabbed this PID after ours died"
 		const pidStartTime = await getProcessStartTime(this.fs, child.pid)
 
-		// Emit starting event with PID, port (port is known at allocation time), and start time
-		this.notifyStatusChanged(sessionId, config.type, 'starting', port, undefined, child.pid, pidStartTime)
+		// Emit starting event with PID, port, resolved cwd/command, and start time.
+		this.notifyStatusChanged(sessionId, config.type, 'starting', { port, pid: child.pid, pidStartTime, cwd, command })
 
 		const logs = new RingBuffer(logBufferSize)
 		const startTime = Date.now()
@@ -291,10 +369,70 @@ export class ServiceExecutor {
 			pid: child.pid,
 			status: 'starting',
 			port,
+			cwd,
+			command,
 			logs,
 		}
 		this.services.set(config.type, entry)
 
+		let startupTimer: ReturnType<typeof setTimeout> | undefined
+		let readyCheckTimer: ReturnType<typeof setInterval> | undefined
+		let readyCheckInFlight = false
+
+		const clearReadinessTimers = () => {
+			if (startupTimer) {
+				clearTimeout(startupTimer)
+				startupTimer = undefined
+			}
+			if (readyCheckTimer) {
+				clearInterval(readyCheckTimer)
+				readyCheckTimer = undefined
+			}
+		}
+
+		const markReady = (matchedLine?: string) => {
+			const current = this.services.get(config.type)
+			if (!current || current.process !== child || current.status !== 'starting') return
+
+			current.status = 'ready'
+			clearReadinessTimers()
+			this.portConflictRetries.delete(config.type)
+			const startupDurationMs = Date.now() - startTime
+			this.notifyStatusChanged(sessionId, config.type, 'ready', {
+				port: current.port,
+				cwd: current.cwd,
+				command: current.command,
+			})
+			this.logger.info('Service ready', {
+				serviceType: config.type,
+				port: current.port,
+				startupDurationMs,
+				matchedLine,
+			})
+		}
+
+		const readyArgs = (): ServiceStartArgs => ({
+			...startArgs,
+			logs: logs.toArray(),
+		})
+
+		const checkReadyWhen = async () => {
+			if (!config.readyWhen || readyCheckInFlight) return
+			const current = this.services.get(config.type)
+			if (!current || current.process !== child || current.status !== 'starting') return
+
+			readyCheckInFlight = true
+			try {
+				if (await config.readyWhen(readyArgs())) {
+					markReady()
+				}
+			} catch {
+				// The service may not be reachable yet; keep polling until timeout.
+			} finally {
+				readyCheckInFlight = false
+			}
+		}
+
 		const processLine = (line: string) => {
 			logs.push(line)
 			if (PORT_CONFLICT_PATTERN.test(line)) {
@@ -307,27 +445,17 @@ export class ServiceExecutor {
 				this.logger.debug('Service output', { serviceType: config.type, line })
 			}
 
-			// Check for ready pattern
 			if (readyRegex && current.status === 'starting') {
 				if (readyRegex.test(line)) {
-					current.status = 'ready'
-					if (startupTimer) clearTimeout(startupTimer)
-					this.portConflictRetries.delete(config.type)
-					const startupDurationMs = Date.now() - startTime
-					this.notifyStatusChanged(sessionId, config.type, 'ready', current.port)
-					this.logger.info('Service ready', {
-						serviceType: config.type,
-						port: current.port,
-						startupDurationMs,
-						matchedLine: line,
-					})
+					markReady(line)
 				}
 			}
+
+			void checkReadyWhen()
 		}
 
 		// Startup timeout — mark as failed if not ready in time
-		let startupTimer: ReturnType<typeof setTimeout> | undefined
-		if (readyRegex) {
+		if (readyRegex || config.readyWhen) {
 			startupTimer = setTimeout(() => {
 				const current = this.services.get(config.type)
 				if (!current || current.process !== child || current.status !== 'starting') return
@@ -335,7 +463,13 @@ export class ServiceExecutor {
 				current.status = 'failed'
 				const errorMsg = `Service startup timed out after ${startupTimeoutMs}ms`
 				this.logger.error(errorMsg, undefined, { serviceType: config.type })
-				this.notifyStatusChanged(sessionId, config.type, 'failed', undefined, errorMsg)
+				clearReadinessTimers()
+				this.notifyStatusChanged(sessionId, config.type, 'failed', {
+					port: current.port,
+					cwd: current.cwd,
+					command: current.command,
+					error: errorMsg,
+				})
 
 				// Kill the timed-out process
 				try {
@@ -346,6 +480,14 @@ export class ServiceExecutor {
 			}, startupTimeoutMs)
 		}
 
+		if (config.readyWhen) {
+			const intervalMs = config.readyCheckIntervalMs ?? 250
+			readyCheckTimer = setInterval(() => {
+				void checkReadyWhen()
+			}, intervalMs)
+			void checkReadyWhen()
+		}
+
 		// Pipe stdout/stderr line by line
 		let stdoutPartial = ''
 		child.stdout?.on('data', (data: Buffer) => {
@@ -369,7 +511,7 @@ export class ServiceExecutor {
 
 		// Handle unexpected exit
 		child.on('close', (code) => {
-			if (startupTimer) clearTimeout(startupTimer)
+			clearReadinessTimers()
 			// Flush remaining partial lines
 			if (stdoutPartial) {
 				processLine(stdoutPartial)
@@ -413,7 +555,12 @@ export class ServiceExecutor {
 				// Unexpected exit
 				current.status = 'failed'
 				const errorMsg = `Process exited unexpectedly with code ${code}`
-				this.notifyStatusChanged(sessionId, config.type, 'failed', undefined, errorMsg)
+				this.notifyStatusChanged(sessionId, config.type, 'failed', {
+					port: current.port,
+					cwd: current.cwd,
+					command: current.command,
+					error: errorMsg,
+				})
 				this.logger.warn('Service process exited unexpectedly', {
 					serviceType: config.type,
 					code,
@@ -433,9 +580,8 @@ export class ServiceExecutor {
 		})
 
 		// If no ready pattern, immediately mark as ready
-		if (!readyRegex) {
-			entry.status = 'ready'
-			this.notifyStatusChanged(sessionId, config.type, 'ready', port)
+		if (!readyRegex && !config.readyWhen) {
+			markReady()
 		}
 
 		return Ok(undefined)
@@ -564,7 +710,11 @@ export class ServiceExecutor {
 		}
 
 		entry.status = 'ready'
-		this.notifyStatusChanged(sessionId, config.type, 'ready', entry.port)
+		this.notifyStatusChanged(sessionId, config.type, 'ready', {
+			port: entry.port,
+			cwd: entry.cwd,
+			command: entry.command,
+		})
 
 		this.logger.info('Service resumed', { serviceType: config.type })
 		return Ok(undefined)

package/src/plugins/services/services.integration.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from 'bun:test'
-import { readFile, rm } from 'node:fs/promises'
+import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { MemoryEventStore } from '~/core/events/memory.js'
@@ -13,7 +13,7 @@ import { createTestPreset, TestHarness } from '~/testing/index.js'
 import { serviceEvents, servicePlugin } from './plugin.js'
 import type { ServiceAgentConfig, ServicePluginConfig } from './plugin.js'
 import { PortPool } from './port-pool.js'
-import type { ServiceConfig, ServiceEntry, ServiceStatus } from './schema.js'
+import type { ServiceCommandArgs, ServiceConfig, ServiceCwdArgs, ServiceEntry, ServiceStatus } from './schema.js'
 import { ServiceExecutor } from './service.js'
 
 // ============================================================================
@@ -278,6 +278,84 @@ describe('services plugin', () => {
 			const serviceState = selectPluginState<Map<string, ServiceEntry>>(session.state, 'services')?.get('callback-service')
 			expect(serviceState!.port).toBeGreaterThanOrEqual(10000)
 		})
+
+		it('resolves cwd, command, and env callbacks with runtime context', async () => {
+			const workspaceDir = await mkdtemp(join(tmpdir(), 'roj-svc-runtime-'))
+			const webDir = join(workspaceDir, 'packages', 'web')
+			await mkdir(webDir, { recursive: true })
+
+			let cwdArgs: ServiceCwdArgs | undefined
+			let commandArgs: ServiceCommandArgs | undefined
+			let envArgs: ServiceCommandArgs | undefined
+
+			const runtimeService: ServiceConfig = {
+				type: 'runtime',
+				description: 'Service with runtime resolvers',
+				cwd: (args) => {
+					cwdArgs = args
+					return 'packages/web'
+				},
+				command: async (args) => {
+					commandArgs = args
+					return `printf "%s" "$RUNTIME_MARKER" > marker.txt && echo "READY ${args.port}" && sleep 60`
+				},
+				env: (args) => {
+					envArgs = args
+					return {
+						RUNTIME_MARKER: `${args.sessionId}|${args.workspaceDir}|${args.cwd}|${args.port}`,
+					}
+				},
+				readyPattern: 'READY',
+			}
+
+			try {
+				const portPool = new PortPool()
+				const harness = createServicesHarness({
+					presets: [createServicesPreset([runtimeService], ['runtime'], portPool, { workspaceDir })],
+					llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
+				})
+
+				const session = await harness.createSession('test')
+				const entryAgentId = session.getEntryAgentId()!
+				const startResult = await session.callPluginMethod('services.start', {
+					sessionId: String(session.sessionId),
+					agentId: String(entryAgentId),
+					serviceType: 'runtime',
+				})
+				expect(startResult.ok).toBe(true)
+				await waitForServiceStatus(session, 'runtime', 'ready')
+
+				const serviceState = selectPluginState<Map<string, ServiceEntry>>(session.state, 'services')?.get('runtime')
+				expect(cwdArgs?.workspaceDir).toBe(workspaceDir)
+				expect(cwdArgs?.sessionId).toBe(String(session.sessionId))
+				expect(commandArgs?.cwd).toBe(webDir)
+				expect(commandArgs?.workspaceDir).toBe(workspaceDir)
+				expect(envArgs?.cwd).toBe(webDir)
+				expect(serviceState?.cwd).toBe(webDir)
+				expect(serviceState?.command).toContain('RUNTIME_MARKER')
+
+				const marker = await readFile(join(webDir, 'marker.txt'), 'utf-8')
+				expect(marker).toContain(String(session.sessionId))
+				expect(marker).toContain(workspaceDir)
+				expect(marker).toContain(webDir)
+
+				const statusResult = await session.callPluginMethod('services.status', {
+					sessionId: String(session.sessionId),
+					agentId: String(entryAgentId),
+					serviceType: 'runtime',
+				})
+				expect(statusResult).toMatchObject({
+					ok: true,
+					value: {
+						status: 'ready',
+						cwd: webDir,
+						command: serviceState?.command,
+					},
+				})
+			} finally {
+				await rm(workspaceDir, { recursive: true, force: true })
+			}
+		})
 	})
 
 	// =========================================================================
@@ -379,6 +457,35 @@ describe('services plugin', () => {
 			const autoEvents = events.filter((e) => e.serviceType === 'auto-start')
 			expect(autoEvents.length).toBeGreaterThanOrEqual(1)
 		})
+
+		it('availableWhen false skips auto-start and explicit start returns an error', async () => {
+			const unavailableService: ServiceConfig = {
+				type: 'unavailable',
+				description: 'Unavailable service',
+				command: 'sleep 60',
+				autoStart: true,
+				availableWhen: () => false,
+			}
+			const portPool = new PortPool()
+			const harness = createServicesHarness({
+				presets: [createServicesPreset([unavailableService], ['unavailable'], portPool)],
+				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
+			})
+
+			const session = await harness.createSession('test')
+			await new Promise((resolve) => setTimeout(resolve, 100))
+
+			const events = await session.getEventsByType(serviceEvents, 'service_status_changed')
+			expect(events.some((event) => event.serviceType === 'unavailable')).toBe(false)
+
+			const entryAgentId = session.getEntryAgentId()!
+			const result = await session.callPluginMethod('services.start', {
+				sessionId: String(session.sessionId),
+				agentId: String(entryAgentId),
+				serviceType: 'unavailable',
+			})
+			expect(result.ok).toBe(false)
+		})
 	})
 
 	// =========================================================================
@@ -439,6 +546,38 @@ describe('services plugin', () => {
 			const serviceState = selectPluginState<Map<string, ServiceEntry>>(session.state, 'services')?.get('ready-service')
 			expect(serviceState!.status).toBe('ready')
 		})
+
+		it('readyWhen can mark a service ready without output pattern', async () => {
+			let checks = 0
+			const readyWhenService: ServiceConfig = {
+				type: 'ready-when',
+				description: 'Service with callback readiness',
+				command: 'sleep 60',
+				readyWhen: () => {
+					checks += 1
+					return checks > 1
+				},
+				readyCheckIntervalMs: 20,
+				startupTimeoutMs: 1000,
+			}
+			const portPool = new PortPool()
+			const harness = createServicesHarness({
+				presets: [createServicesPreset([readyWhenService], ['ready-when'], portPool)],
+				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
+			})
+
+			const session = await harness.createSession('test')
+			const entryAgentId = session.getEntryAgentId()!
+			const result = await session.callPluginMethod('services.start', {
+				sessionId: String(session.sessionId),
+				agentId: String(entryAgentId),
+				serviceType: 'ready-when',
+			})
+			expect(result.ok).toBe(true)
+
+			await waitForServiceStatus(session, 'ready-when', 'ready')
+			expect(checks).toBeGreaterThan(1)
+		})
 	})
 
 	// =========================================================================
@@ -658,8 +797,8 @@ describe('services plugin', () => {
 			}
 
 			const observed: Array<{ status: ServiceStatus; port?: number }> = []
-			executor.onStatusChanged = (_sessionId, _serviceType, status, port) => {
-				observed.push({ status, port })
+			executor.onStatusChanged = (_sessionId, _serviceType, status, details) => {
+				observed.push({ status, port: details.port })
 			}
 
 			try {

package/src/testing/preset-helpers.ts

@@ -12,6 +12,7 @@ export type TestAgentDefinition<TInput = unknown> = Omit<AgentDefinition<TInput>
  */
 export function createTestPreset(overrides?: {
 	id?: string
+	workspaceDir?: string
 	orchestratorSystem?: string
 	agents?: TestAgentDefinition[]
 	plugins?: SessionPluginConfig[]
@@ -22,6 +23,7 @@ export function createTestPreset(overrides?: {
 	return {
 		id: overrides?.id ?? 'test',
 		name: 'Test Preset',
+		workspaceDir: overrides?.workspaceDir,
 		orchestrator: {
 			system: overrides?.orchestratorSystem ?? 'You are a test agent.',
 			model: ModelId('mock'),

package/src/testing/test-harness.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'bun:test'
 import { MockLLMProvider } from '~/core/llm/mock.js'
 import { ToolCallId } from '~/core/tools/schema.js'
+import { definePlugin, Ok, selectSessionStats, sessionStatsPlugin, type SessionStatsState, z } from '~/index.js'
 import { createTestPreset, TestHarness } from './index.js'
 
 describe('TestHarness', () => {
@@ -60,4 +61,54 @@ describe('TestHarness', () => {
 
 		await harness.shutdown()
 	})
+
+	it('includes session stats by default and exposes plugin state', async () => {
+		expect(sessionStatsPlugin.name).toBe('session-stats')
+
+		const harness = new TestHarness({
+			presets: [createTestPreset()],
+			llmProvider: MockLLMProvider.withFixedResponse({
+				content: 'Done',
+				toolCalls: [],
+				metrics: MockLLMProvider.defaultMetricsWithCost(1.25),
+			}),
+			// Passing a default plugin explicitly should not register it twice.
+			systemPlugins: [sessionStatsPlugin],
+		})
+
+		const session = await harness.createSession('test')
+		await session.sendAndWaitForIdle('Test')
+
+		const stats = session.getPluginState<SessionStatsState>('sessionStats')
+		expect(stats?.llmCalls).toBe(1)
+		expect(stats?.totalCost).toBe(1.25)
+		expect(selectSessionStats(session.state).totalCost).toBe(1.25)
+
+		await harness.shutdown()
+	})
+
+	it('callPluginMethod can pass caller context', async () => {
+		const callerPlugin = definePlugin('caller')
+			.method('whoami', {
+				input: z.object({}),
+				output: z.object({ source: z.string() }),
+				handler: async ctx => Ok({ source: ctx.caller.source }),
+			})
+			.build()
+
+		const harness = new TestHarness({
+			presets: [createTestPreset()],
+			systemPlugins: [callerPlugin],
+		})
+
+		const session = await harness.createSession('test')
+		const result = await session.callPluginMethod('caller.whoami', {}, { caller: { source: 'system', meta: {} } })
+
+		expect(result.ok).toBe(true)
+		if (result.ok) {
+			expect(result.value).toEqual({ source: 'system' })
+		}
+
+		await harness.shutdown()
+	})
 })