@namzu/sdk 0.1.5-rc.1-fix → 0.1.5

package/src/rag/vector-store.ts

@@ -1,4 +1,4 @@
-import type { ChunkId, DocumentId, KnowledgeBaseId } from '../types/ids/index.js'
+import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
 import type {
 	Chunk,
 	VectorSearchResult,
@@ -57,7 +57,7 @@ export class InMemoryVectorStore implements VectorStore {
 		}
 	}
 
-	async deleteByKnowledgeBase(knowledgeBaseId: KnowledgeBaseId, tenantId: string): Promise<void> {
+	async deleteByKnowledgeBase(knowledgeBaseId: KnowledgeBaseId, tenantId: TenantId): Promise<void> {
 		for (const [id, chunk] of this.chunks) {
 			if (chunk.knowledgeBaseId === knowledgeBaseId && chunk.tenantId === tenantId) {
 				this.chunks.delete(id)

package/src/registry/ManagedRegistry.ts

@@ -4,16 +4,23 @@ import { Registry } from './Registry.js'
 export interface ManagedRegistryConfig<TDefinition> {
 	componentName: string
 	idField?: keyof TDefinition & string
+	/**
+	 * Extract id from a full item. Takes precedence over `idField` when provided.
+	 * Required when the id field is nested (e.g. `def.info.id`).
+	 */
+	computeId?: (item: TDefinition) => string
 	logger?: Logger
 }
 
 export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
 	protected log: Logger
 	private idField?: keyof TDefinition & string
+	private computeId?: (item: TDefinition) => string
 
 	constructor(config: ManagedRegistryConfig<TDefinition>) {
 		super()
 		this.idField = config.idField
+		this.computeId = config.computeId
 		this.log = (config.logger ?? getRootLogger()).child({
 			component: config.componentName,
 		})
@@ -45,10 +52,14 @@ export class ManagedRegistry<TDefinition> extends Registry<TDefinition> {
 		}
 
 		const item = idOrItem
-		if (!this.idField) {
-			throw new Error('register(item) requires idField to be configured')
+		const id = this.computeId
+			? this.computeId(item)
+			: this.idField
+				? String(item[this.idField])
+				: undefined
+		if (id === undefined) {
+			throw new Error('register(item) requires idField or computeId to be configured')
 		}
-		const id = String(item[this.idField])
 
 		if (this.has(id)) {
 			this.log.warn(`"${id}" already registered, overwriting.`)

package/src/registry/agent/definitions.ts

@@ -1,61 +1,11 @@
 import type { AgentType, BaseAgentConfig, BaseAgentResult } from '../../types/agent/base.js'
 import type { Agent } from '../../types/agent/core.js'
 import type { AgentDefinition } from '../../types/agent/factory.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
-import { Registry } from '../Registry.js'
-
-export class AgentRegistry extends Registry<AgentDefinition> {
-	private log: Logger
+import { ManagedRegistry } from '../ManagedRegistry.js'
 
+export class AgentRegistry extends ManagedRegistry<AgentDefinition> {
 	constructor() {
-		super()
-		this.log = getRootLogger().child({ component: 'AgentRegistry' })
-	}
-
-	override register(id: string, definition: AgentDefinition): void
-	override register(definition: AgentDefinition): void
-	override register(definitions: AgentDefinition[]): void
-	override register(
-		idOrDef: string | AgentDefinition | AgentDefinition[],
-		maybeDef?: AgentDefinition,
-	): void {
-		if (Array.isArray(idOrDef)) {
-			for (const def of idOrDef) {
-				this.register(def)
-			}
-			return
-		}
-
-		if (typeof idOrDef === 'string') {
-			if (!maybeDef) {
-				throw new Error('register(id, definition) requires a definition argument')
-			}
-			const id = idOrDef
-			const def = maybeDef
-			if (this.has(id)) {
-				this.log.warn(`Agent "${id}" already registered, overwriting.`)
-			}
-			super.register(id, def)
-			this.log.info(`Agent registered: ${id}`)
-			return
-		}
-
-		const def = idOrDef
-		const id = def.info.id
-
-		if (this.has(id)) {
-			this.log.warn(`Agent "${id}" already registered, overwriting.`)
-		}
-		super.register(id, def)
-		this.log.info(`Agent registered: ${id}`)
-	}
-
-	getOrThrow(id: string): AgentDefinition {
-		const def = this.get(id)
-		if (!def) {
-			throw new Error(`Agent not found: "${id}". Available: ${this.listIds().join(', ')}`)
-		}
-		return def
+		super({ componentName: 'AgentRegistry', computeId: (def) => def.info.id })
 	}
 
 	resolve(agentId: string): Agent<BaseAgentConfig, BaseAgentResult> {

package/src/registry/connector/definitions.ts

@@ -1,59 +1,9 @@
 import type { ConnectorDefinition } from '../../types/connector/index.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
-import { Registry } from '../Registry.js'
-
-export class ConnectorRegistry extends Registry<ConnectorDefinition> {
-	private log: Logger
+import { ManagedRegistry } from '../ManagedRegistry.js'
 
+export class ConnectorRegistry extends ManagedRegistry<ConnectorDefinition> {
 	constructor() {
-		super()
-		this.log = getRootLogger().child({ component: 'ConnectorRegistry' })
-	}
-
-	override register(id: string, definition: ConnectorDefinition): void
-	override register(definition: ConnectorDefinition): void
-	override register(definitions: ConnectorDefinition[]): void
-	override register(
-		idOrDef: string | ConnectorDefinition | ConnectorDefinition[],
-		maybeDef?: ConnectorDefinition,
-	): void {
-		if (Array.isArray(idOrDef)) {
-			for (const def of idOrDef) {
-				this.register(def)
-			}
-			return
-		}
-
-		if (typeof idOrDef === 'string') {
-			if (!maybeDef) {
-				throw new Error('register(id, definition) requires a definition argument')
-			}
-			const id = idOrDef
-			const def = maybeDef
-			if (this.has(id)) {
-				this.log.warn(`Connector "${id}" is already registered, overwriting.`)
-			}
-			super.register(id, def)
-			this.log.info(`Connector registered: ${id}`)
-			return
-		}
-
-		const def = idOrDef
-		const id = def.id
-
-		if (this.has(id)) {
-			this.log.warn(`Connector "${id}" is already registered, overwriting.`)
-		}
-		super.register(id, def)
-		this.log.info(`Connector registered: ${id}`)
-	}
-
-	getOrThrow(id: string): ConnectorDefinition {
-		const def = this.get(id)
-		if (!def) {
-			throw new Error(`Connector not found: "${id}". Available: ${this.listIds().join(', ')}`)
-		}
-		return def
+		super({ componentName: 'ConnectorRegistry', idField: 'id' })
 	}
 
 	listByType(connectionType: ConnectorDefinition['connectionType']): ConnectorDefinition[] {

package/src/registry/connector/scoped.ts

@@ -8,9 +8,10 @@ import type {
 	ScopedConnectorConfig,
 } from '../../types/connector/index.js'
 import { CONNECTOR_SCOPE_ORDER } from '../../types/connector/index.js'
+import type { ConnectorId } from '../../types/ids/index.js'
 import { type Logger, getRootLogger } from '../../utils/logger.js'
 
-function scopeKey(scope: ConnectorScope, scopeId: string, connectorId: string): string {
+function scopeKey(scope: ConnectorScope, scopeId: string, connectorId: ConnectorId): string {
 	return `${scope}:${scopeId}:${connectorId}`
 }
 
@@ -28,7 +29,7 @@ export class ScopedConnectorRegistry {
 		this.log.info(`Scoped config set: ${key}`)
 	}
 
-	remove(scope: ScopeRef, connectorId: string): boolean {
+	remove(scope: ScopeRef, connectorId: ConnectorId): boolean {
 		const key = scopeKey(scope.scope, scope.scopeId, connectorId)
 		const removed = this.configs.delete(key)
 		if (removed) {
@@ -37,11 +38,11 @@ export class ScopedConnectorRegistry {
 		return removed
 	}
 
-	getAt(scope: ScopeRef, connectorId: string): ScopedConnectorConfig | undefined {
+	getAt(scope: ScopeRef, connectorId: ConnectorId): ScopedConnectorConfig | undefined {
 		return this.configs.get(scopeKey(scope.scope, scope.scopeId, connectorId))
 	}
 
-	resolve(connectorId: string, chain: ScopeChain): ResolvedConnectorConfig | undefined {
+	resolve(connectorId: ConnectorId, chain: ScopeChain): ResolvedConnectorConfig | undefined {
 		const layers: ScopedConnectorConfig[] = []
 
 		for (const scope of CONNECTOR_SCOPE_ORDER) {
@@ -59,7 +60,7 @@ export class ScopedConnectorRegistry {
 		return this.mergeLayers(connectorId, layers)
 	}
 
-	listForConnector(connectorId: string): ScopedConnectorConfig[] {
+	listForConnector(connectorId: ConnectorId): ScopedConnectorConfig[] {
 		const results: ScopedConnectorConfig[] = []
 		for (const config of this.configs.values()) {
 			if (config.connectorId === connectorId) {
@@ -81,7 +82,7 @@ export class ScopedConnectorRegistry {
 	}
 
 	private mergeLayers(
-		connectorId: string,
+		connectorId: ConnectorId,
 		layers: ScopedConnectorConfig[],
 	): ResolvedConnectorConfig {
 		let mergedOptions: Record<string, unknown> = {}

package/src/registry/index.ts

@@ -9,3 +9,4 @@ export { ConnectorRegistry } from './connector/definitions.js'
 export { ScopedConnectorRegistry } from './connector/scoped.js'
 
 export { AgentRegistry } from './agent/definitions.js'
+export { PluginRegistry } from './plugin/index.js'

package/src/registry/tool/execute.ts

@@ -12,21 +12,16 @@ import type {
 	ToolTierConfig,
 } from '../../types/tool/index.js'
 import { toErrorMessage } from '../../utils/error.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
-import { Registry } from '../Registry.js'
+import { ManagedRegistry } from '../ManagedRegistry.js'
 
 export type { ToolExecutionResult }
 
-export class ToolRegistry extends Registry<ToolDefinition> {
-	private log: Logger
+export class ToolRegistry extends ManagedRegistry<ToolDefinition> {
 	private availability: Map<string, ToolAvailability> = new Map()
 	private tierConfig?: ToolTierConfig
 
 	constructor(config?: ToolRegistryConfig) {
-		super()
-		this.log = (config?.logger ?? getRootLogger()).child({
-			component: 'ToolRegistry',
-		})
+		super({ componentName: 'ToolRegistry', idField: 'name', logger: config?.logger })
 		this.tierConfig = config?.tierConfig
 	}
 
@@ -54,10 +49,9 @@ export class ToolRegistry extends Registry<ToolDefinition> {
 		}
 
 		const tool = idOrToolOrTools
-		const id = tool.name
 		const state: ToolAvailability = typeof maybeTool === 'string' ? maybeTool : 'active'
 
-		this.registerOne(id, tool, state)
+		this.registerOne(tool.name, tool, state)
 	}
 
 	private registerOne(id: string, tool: ToolDefinition, state: ToolAvailability): void {
@@ -69,12 +63,8 @@ export class ToolRegistry extends Registry<ToolDefinition> {
 				)
 			}
 		}
-		if (this.has(id)) {
-			this.log.warn(`Tool "${id}" is already registered, overwriting.`)
-		}
 		super.register(id, tool)
 		this.availability.set(id, state)
-		this.log.info(`Tool registered: ${id} (${state})`)
 	}
 
 	override unregister(id: string): boolean {
@@ -150,14 +140,6 @@ export class ToolRegistry extends Registry<ToolDefinition> {
 		return this.tierConfig.guidanceTemplate(this.tierConfig.tiers)
 	}
 
-	getOrThrow(name: string): ToolDefinition {
-		const tool = this.get(name)
-		if (!tool) {
-			throw new Error(`Tool not found: "${name}". Available tools: ${this.listIds().join(', ')}`)
-		}
-		return tool
-	}
-
 	listNames(): string[] {
 		return this.listIds()
 	}

package/src/run/index.ts

@@ -1,9 +1,9 @@
-export { RunPersistence, SessionManager } from '../manager/run/persistence.js'
+export { RunPersistence } from '../manager/run/persistence.js'
 
-export { RunDiskStore, SessionStore } from '../store/run/disk.js'
+export { RunDiskStore } from '../store/run/disk.js'
 
-export { createRunReporter, createSessionReporter } from './reporter.js'
-export type { RunReporter, SessionReporter } from './reporter.js'
+export { createRunReporter } from './reporter.js'
+export type { RunReporter } from './reporter.js'
 
 export { checkLimitsDetailed, buildLimitConfig } from './LimitChecker.js'
 export type { LimitCheckerState, LimitCheckResult } from './LimitChecker.js'

package/src/run/reporter.ts

@@ -16,8 +16,6 @@ export interface RunReporter {
 	summary(run: AgentRun): void
 }
 
-export type SessionReporter = RunReporter
-
 export function createRunReporter(parentLogger?: Logger): RunReporter {
 	const log = (parentLogger ?? getRootLogger()).child({
 		component: 'RunReporter',
@@ -223,5 +221,3 @@ export function createRunReporter(parentLogger?: Logger): RunReporter {
 
 	return { listener, summary }
 }
-
-export const createSessionReporter = createRunReporter

package/src/runtime/query/__tests__/executor-plugin-hooks.test.ts

@@ -0,0 +1,305 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { PluginLifecycleManager } from '../../../plugin/lifecycle.js'
+import { ActivityStore } from '../../../store/activity/memory.js'
+import type { RunId } from '../../../types/ids/index.js'
+import type { PluginHookResult } from '../../../types/plugin/index.js'
+import type { ChatCompletionResponse } from '../../../types/provider/index.js'
+import type { RunEvent } from '../../../types/run/index.js'
+import type { ToolRegistryContract } from '../../../types/tool/index.js'
+import type { Logger } from '../../../utils/logger.js'
+import { ToolExecutor } from '../executor.js'
+
+const mockRunId = 'run_test' as RunId
+
+function makeLogger(): Logger {
+	const stub = {
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		debug: vi.fn(),
+	}
+	return { ...stub, child: vi.fn(() => ({ ...stub, child: vi.fn() })) } as unknown as Logger
+}
+
+function makeToolRegistry(execute: ToolRegistryContract['execute']): ToolRegistryContract {
+	return {
+		register: vi.fn(),
+		unregister: vi.fn(),
+		execute,
+		get: vi.fn(() => undefined),
+		has: vi.fn(() => true),
+		listNames: vi.fn(() => []),
+		getAvailability: vi.fn(),
+	} as unknown as ToolRegistryContract
+}
+
+function makePluginManager(
+	executeHooks: PluginLifecycleManager['executeHooks'],
+): PluginLifecycleManager {
+	return { executeHooks } as unknown as PluginLifecycleManager
+}
+
+function buildResponse(toolName: string, args: object): ChatCompletionResponse {
+	return {
+		message: {
+			role: 'assistant',
+			content: null,
+			toolCalls: [
+				{
+					id: 'call_1',
+					type: 'function',
+					function: { name: toolName, arguments: JSON.stringify(args) },
+				},
+			],
+		},
+		finishReason: 'tool_calls',
+		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+	} as ChatCompletionResponse
+}
+
+describe('ToolExecutor plugin hooks', () => {
+	let activityStore: ActivityStore
+	let emitted: RunEvent[]
+	let emitEvent: (e: RunEvent) => Promise<void>
+
+	beforeEach(() => {
+		activityStore = new ActivityStore(mockRunId, {
+			enabled: true,
+			trackToolCalls: true,
+			trackLlmTurns: true,
+		})
+		emitted = []
+		emitEvent = async (e) => {
+			emitted.push(e)
+		}
+	})
+
+	it('continues normally when no pluginManager is configured', async () => {
+		const tools = makeToolRegistry(vi.fn(async () => ({ success: true, output: 'ok' })))
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		const batch = await exec.executeBatch(buildResponse('echo', { msg: 'hi' }))
+		expect(batch.results[0]?.output).toBe('ok')
+	})
+
+	it('replaces input on pre_tool_use modify', async () => {
+		const executeMock = vi.fn(async () => ({ success: true, output: 'ok' }))
+		const tools = makeToolRegistry(executeMock)
+		const pluginManager = makePluginManager(async (event) =>
+			event === 'pre_tool_use'
+				? ([{ action: 'modify', input: { replaced: true } }] as PluginHookResult[])
+				: [],
+		)
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		await exec.executeBatch(buildResponse('echo', { original: true }))
+		expect(executeMock).toHaveBeenCalledWith('echo', { replaced: true }, expect.any(Object))
+	})
+
+	it('skips registry execution and synthesizes output on pre_tool_use skip', async () => {
+		const executeMock = vi.fn(async () => ({ success: true, output: 'should-not-run' }))
+		const tools = makeToolRegistry(executeMock)
+		const pluginManager = makePluginManager(async (event) =>
+			event === 'pre_tool_use'
+				? ([{ action: 'skip', reason: 'policy' }] as PluginHookResult[])
+				: [],
+		)
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		const batch = await exec.executeBatch(buildResponse('echo', {}))
+		expect(executeMock).not.toHaveBeenCalled()
+		expect(batch.results[0]?.output).toBe('Tool echo skipped by plugin: policy')
+	})
+
+	it('overrides post_tool_use output on error action', async () => {
+		const tools = makeToolRegistry(vi.fn(async () => ({ success: true, output: 'raw' })))
+		const pluginManager = makePluginManager(async (event) =>
+			event === 'post_tool_use'
+				? ([{ action: 'error', message: 'rejected' }] as PluginHookResult[])
+				: [],
+		)
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		const batch = await exec.executeBatch(buildResponse('echo', {}))
+		expect(batch.results[0]?.output).toBe('Error: rejected')
+	})
+
+	it('threads modified input through chained pre_tool_use modify hooks', async () => {
+		const seenInputs: unknown[] = []
+		const executeMock = vi.fn(async (_name, input) => {
+			seenInputs.push(input)
+			return { success: true, output: 'ok' }
+		})
+		const tools = makeToolRegistry(executeMock)
+		const handlers = [
+			async (ctx: any) => {
+				seenInputs.push(['hook1-saw', ctx.toolInput])
+				return { action: 'modify', input: { step: 1 } } as PluginHookResult
+			},
+			async (ctx: any) => {
+				seenInputs.push(['hook2-saw', ctx.toolInput])
+				return { action: 'modify', input: { step: 2 } } as PluginHookResult
+			},
+		]
+		// Real PluginLifecycleManager so the modify-threading path is exercised end-to-end.
+		const { PluginLifecycleManager } = await import('../../../plugin/lifecycle.js')
+		const realManager = new PluginLifecycleManager({
+			pluginRegistry: {} as any,
+			toolRegistry: {} as any,
+			log: makeLogger(),
+		})
+		realManager['hookHandlers'].set('pre_tool_use', [
+			{ pluginId: 'p1' as any, handler: handlers[0] as any },
+			{ pluginId: 'p2' as any, handler: handlers[1] as any },
+		])
+
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager: realManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		await exec.executeBatch(buildResponse('echo', { original: true }))
+		expect(seenInputs).toEqual([
+			['hook1-saw', { original: true }],
+			['hook2-saw', { step: 1 }],
+			{ step: 2 },
+		])
+	})
+
+	it('carries modified input into synthetic skip outcome (modify -> skip chain)', async () => {
+		const executeMock = vi.fn(async () => ({ success: true, output: 'should-not-run' }))
+		const tools = makeToolRegistry(executeMock)
+		const { PluginLifecycleManager } = await import('../../../plugin/lifecycle.js')
+		const realManager = new PluginLifecycleManager({
+			pluginRegistry: {} as any,
+			toolRegistry: {} as any,
+			log: makeLogger(),
+		})
+		const seenInputs: unknown[] = []
+		realManager['hookHandlers'].set('pre_tool_use', [
+			{
+				pluginId: 'p1' as any,
+				handler: (async (ctx: any) => {
+					seenInputs.push(['hook1', ctx.toolInput])
+					return { action: 'modify', input: { patched: true } }
+				}) as any,
+			},
+			{
+				pluginId: 'p2' as any,
+				handler: (async (ctx: any) => {
+					seenInputs.push(['hook2', ctx.toolInput])
+					return { action: 'skip', reason: 'after patch' }
+				}) as any,
+			},
+		])
+
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager: realManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		const batch = await exec.executeBatch(buildResponse('echo', { original: true }))
+		expect(executeMock).not.toHaveBeenCalled()
+		expect(batch.results[0]?.output).toBe('Tool echo skipped by plugin: after patch')
+		expect(seenInputs).toEqual([
+			['hook1', { original: true }],
+			['hook2', { patched: true }],
+		])
+		// Synthetic tool_executing event should carry the modified input, not the original.
+		const executingEvent = emitted.find((e) => e.type === 'tool_executing')
+		expect(executingEvent).toMatchObject({
+			type: 'tool_executing',
+			toolName: 'echo',
+			input: { patched: true },
+		})
+	})
+
+	it('throws on pre_tool_use retry misuse', async () => {
+		const tools = makeToolRegistry(vi.fn(async () => ({ success: true, output: 'ok' })))
+		const pluginManager = makePluginManager(async (event) =>
+			event === 'pre_tool_use' ? ([{ action: 'retry' }] as PluginHookResult[]) : [],
+		)
+		const exec = new ToolExecutor(
+			{
+				tools,
+				runId: mockRunId,
+				workingDirectory: '/tmp',
+				permissionMode: 'auto',
+				env: {},
+				abortSignal: new AbortController().signal,
+				pluginManager,
+			},
+			activityStore,
+			emitEvent,
+			makeLogger(),
+		)
+		await expect(exec.executeBatch(buildResponse('echo', {}))).rejects.toThrow(
+			/unsupported action 'retry'/,
+		)
+	})
+})

package/src/runtime/query/__tests__/plugin-hooks.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import type { PluginHookResult } from '../../../types/plugin/index.js'
+import { applyLifecycleHookResults } from '../plugin-hooks.js'
+
+describe('applyLifecycleHookResults', () => {
+	it('returns silently when all results are continue', () => {
+		const results: PluginHookResult[] = [{ action: 'continue' }, { action: 'continue' }]
+		expect(() => applyLifecycleHookResults('run_start', results)).not.toThrow()
+	})
+
+	it('throws when a result is error', () => {
+		const results: PluginHookResult[] = [{ action: 'error', message: 'kaboom' }]
+		expect(() => applyLifecycleHookResults('pre_llm_call', results)).toThrow(
+			/pre_llm_call reported error: kaboom/,
+		)
+	})
+
+	it.each([
+		['skip', { action: 'skip', reason: 'no' } as PluginHookResult],
+		['modify', { action: 'modify', input: {} } as PluginHookResult],
+		['retry', { action: 'retry' } as PluginHookResult],
+		['resume', { action: 'resume', input: 'x' } as PluginHookResult],
+	])('throws on unsupported %s action for lifecycle event', (_, result) => {
+		expect(() => applyLifecycleHookResults('iteration_start', [result])).toThrow(
+			/unsupported action/,
+		)
+	})
+})