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

package/src/runtime/query/executor.ts

@@ -1,14 +1,16 @@
 import { extractFromToolCall, extractFromToolResult } from '../../compaction/extractor.js'
 import type { WorkingStateManager } from '../../compaction/manager.js'
+import type { PluginLifecycleManager } from '../../plugin/lifecycle.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
 import type { RunId } from '../../types/ids/index.js'
 import type { InvocationState } from '../../types/invocation/index.js'
 import { type Message, createToolMessage } from '../../types/message/index.js'
 import type { PermissionMode } from '../../types/permission/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 { Sandbox } from '../../types/sandbox/index.js'
-import type { ToolContext, ToolRegistryContract } from '../../types/tool/index.js'
+import type { ToolContext, ToolRegistryContract, ToolResult } from '../../types/tool/index.js'
 import type { Logger } from '../../utils/logger.js'
 import { compressShellOutput } from '../../utils/shell-compress.js'
 
@@ -23,8 +25,14 @@ export interface ToolExecutorConfig {
 	abortSignal: AbortSignal
 	sandbox?: Sandbox
 	invocationState?: InvocationState
+	pluginManager?: PluginLifecycleManager
 }
 
+type PreToolHookOutcome =
+	| { kind: 'continue'; input: unknown }
+	| { kind: 'skip'; input: unknown; output: string }
+	| { kind: 'error'; input: unknown; output: string }
+
 export interface ToolExecutionBatch {
 	messages: Message[]
 	results: Array<{ toolCallId: string; output: string }>
@@ -118,6 +126,12 @@ export class ToolExecutor {
 			}
 		}
 
+		const preOutcome = await this.runPreToolHook(toolName, input)
+		if (preOutcome.kind === 'skip' || preOutcome.kind === 'error') {
+			return this.recordSyntheticHookOutcome(toolCall.id, toolName, preOutcome.input, preOutcome)
+		}
+		input = preOutcome.input
+
 		const activity = this.activityStore.create({
 			type: 'tool_call',
 			description: toolName,
@@ -137,7 +151,7 @@ export class ToolExecutor {
 		})
 
 		if (this.workingStateManager) {
-			extractFromToolCall(this.workingStateManager, toolName, toolCall.function.arguments)
+			extractFromToolCall(this.workingStateManager, toolName, JSON.stringify(input))
 		}
 
 		const startMs = Date.now()
@@ -148,10 +162,17 @@ export class ToolExecutor {
 			? result.output
 			: `Error: ${result.error ?? 'Tool execution failed'}`
 
-		const output = result.success ? this.maybeCompress(toolName, rawOutput) : rawOutput
+		let output = result.success ? this.maybeCompress(toolName, rawOutput) : rawOutput
+
+		const postOverride = await this.runPostToolHook(toolName, input, result)
+		if (postOverride !== null) {
+			output = postOverride
+		}
+
+		const effectiveIsError = !result.success || postOverride !== null
 
 		if (this.workingStateManager) {
-			extractFromToolResult(this.workingStateManager, toolName, output, !result.success)
+			extractFromToolResult(this.workingStateManager, toolName, output, effectiveIsError)
 		}
 
 		if (result.success) {
@@ -171,10 +192,10 @@ export class ToolExecutor {
 		}
 
 		if (activity) {
-			if (result.success) {
-				this.activityStore.complete(activity.id, output)
+			if (effectiveIsError) {
+				this.activityStore.fail(activity.id, output)
 			} else {
-				this.activityStore.fail(activity.id, result.error ?? 'Tool execution failed')
+				this.activityStore.complete(activity.id, output)
 			}
 		}
 
@@ -188,6 +209,126 @@ export class ToolExecutor {
 		return { toolCallId: toolCall.id, output }
 	}
 
+	private async runPreToolHook(toolName: string, input: unknown): Promise<PreToolHookOutcome> {
+		if (!this.config.pluginManager) return { kind: 'continue', input }
+		const results = await this.config.pluginManager.executeHooks(
+			'pre_tool_use',
+			{ runId: this.config.runId, toolName, toolInput: input },
+			this.emitEvent,
+		)
+		return this.interpretPreToolResults(toolName, input, results)
+	}
+
+	private interpretPreToolResults(
+		toolName: string,
+		initialInput: unknown,
+		results: readonly PluginHookResult[],
+	): PreToolHookOutcome {
+		let currentInput = initialInput
+		for (const result of results) {
+			switch (result.action) {
+				case 'continue':
+					continue
+				case 'modify':
+					currentInput = result.input
+					continue
+				case 'skip':
+					return {
+						kind: 'skip',
+						input: currentInput,
+						output: `Tool ${toolName} skipped by plugin: ${result.reason}`,
+					}
+				case 'error':
+					return {
+						kind: 'error',
+						input: currentInput,
+						output: `Error: ${result.message}`,
+					}
+				case 'retry':
+				case 'resume':
+					throw new Error(
+						`Plugin hook pre_tool_use returned unsupported action '${result.action}' for tool ${toolName}`,
+					)
+				default: {
+					const _exhaustive: never = result
+					throw new Error(`Unknown PluginHookResult: ${JSON.stringify(_exhaustive)}`)
+				}
+			}
+		}
+		return { kind: 'continue', input: currentInput }
+	}
+
+	private async runPostToolHook(
+		toolName: string,
+		input: unknown,
+		toolResult: ToolResult,
+	): Promise<string | null> {
+		if (!this.config.pluginManager) return null
+		const results = await this.config.pluginManager.executeHooks(
+			'post_tool_use',
+			{ runId: this.config.runId, toolName, toolInput: input, toolResult },
+			this.emitEvent,
+		)
+		let override: string | null = null
+		for (const result of results) {
+			switch (result.action) {
+				case 'continue':
+					continue
+				case 'error':
+					override = `Error: ${result.message}`
+					continue
+				case 'skip':
+				case 'modify':
+				case 'retry':
+				case 'resume':
+					throw new Error(
+						`Plugin hook post_tool_use returned unsupported action '${result.action}' for tool ${toolName}`,
+					)
+				default: {
+					const _exhaustive: never = result
+					throw new Error(`Unknown PluginHookResult: ${JSON.stringify(_exhaustive)}`)
+				}
+			}
+		}
+		return override
+	}
+
+	private async recordSyntheticHookOutcome(
+		toolCallId: string,
+		toolName: string,
+		input: unknown,
+		outcome: { kind: 'skip' | 'error'; output: string },
+	): Promise<{ toolCallId: string; output: string }> {
+		const activity = this.activityStore.create({
+			type: 'tool_call',
+			description: toolName,
+			input,
+			toolName,
+			toolCallId,
+		})
+		if (activity) {
+			this.activityStore.start(activity.id)
+			if (outcome.kind === 'skip') {
+				this.activityStore.complete(activity.id, outcome.output)
+			} else {
+				this.activityStore.fail(activity.id, outcome.output)
+			}
+		}
+		await this.emitEvent({
+			type: 'tool_executing',
+			runId: this.config.runId,
+			toolName,
+			input,
+		})
+		await this.emitEvent({
+			type: 'tool_completed',
+			runId: this.config.runId,
+			toolName,
+			result: outcome.output,
+		})
+		return { toolCallId, output: outcome.output }
+	}
+
 	private maybeCompress(toolName: string, output: string): string {
 		const tool = this.config.tools.get(toolName)
 		if (!tool || tool.category !== 'shell') {

package/src/runtime/query/index.ts

@@ -40,6 +40,7 @@ import { RunContextFactory } from './context.js'
 import { EventTranslator } from './events.js'
 import { GuardCoordinator } from './guard.js'
 import { IterationOrchestrator } from './iteration/index.js'
+import { applyLifecycleHookResults } from './plugin-hooks.js'
 import { PromptBuilder } from './prompt.js'
 import type { PromptSegments } from './prompt.js'
 import { ResultAssembler } from './result.js'
@@ -193,6 +194,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Agen
 			env: params.runConfig.env ?? {},
 			abortSignal: ctx.abortController.signal,
 			invocationState: params.invocationState,
+			pluginManager: params.pluginManager,
 		},
 		ctx.activityStore,
 		eventTranslator.emitEvent,
@@ -397,9 +399,13 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Agen
 			yield* eventTranslator.drainPending()
 
 			if (params.pluginManager) {
-				await params.pluginManager.executeHooks('run_start', {
-					runId: ctx.runId,
-				})
+				const hookResults = await params.pluginManager.executeHooks(
+					'run_start',
+					{ runId: ctx.runId },
+					eventTranslator.emitEvent,
+				)
+				applyLifecycleHookResults('run_start', hookResults)
+				yield* eventTranslator.drainPending()
 			}
 
 			// --- Sandbox lifecycle: create before iteration loop ---
@@ -429,9 +435,13 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Agen
 			yield* iterationOrchestrator.runLoop()
 
 			if (params.pluginManager) {
-				await params.pluginManager.executeHooks('run_end', {
-					runId: ctx.runId,
-				})
+				const hookResults = await params.pluginManager.executeHooks(
+					'run_end',
+					{ runId: ctx.runId },
+					eventTranslator.emitEvent,
+				)
+				applyLifecycleHookResults('run_end', hookResults)
+				yield* eventTranslator.drainPending()
 			}
 
 			yield* resultAssembler.completeRun(rootSpan)

package/src/runtime/query/iteration/index.ts

@@ -19,6 +19,7 @@ import type { CheckpointManager } from '../checkpoint.js'
 import type { EmitEvent } from '../events.js'
 import type { ToolExecutor } from '../executor.js'
 import type { GuardCoordinator } from '../guard.js'
+import { applyLifecycleHookResults } from '../plugin-hooks.js'
 import { runAdvisoryPhase } from './phases/advisory.js'
 import { runIterationCheckpoint } from './phases/checkpoint.js'
 import { runCompactionCheck } from './phases/compaction.js'
@@ -175,10 +176,13 @@ export class IterationOrchestrator {
 
 				try {
 					if (this.ctx.pluginManager) {
-						await this.ctx.pluginManager.executeHooks('iteration_start', {
-							runId: runMgr.id,
-							iteration: iterationNum,
-						})
+						const hookResults = await this.ctx.pluginManager.executeHooks(
+							'iteration_start',
+							{ runId: runMgr.id, iteration: iterationNum },
+							this.ctx.emitEvent,
+						)
+						applyLifecycleHookResults('iteration_start', hookResults)
+						yield* this.ctx.drainPending()
 					}
 
 					if (this.ctx.pendingNotifications.length > 0) {
@@ -201,10 +205,13 @@ export class IterationOrchestrator {
 						: runMgr.messages
 
 					if (this.ctx.pluginManager) {
-						await this.ctx.pluginManager.executeHooks('pre_llm_call', {
-							runId: runMgr.id,
-							iteration: iterationNum,
-						})
+						const hookResults = await this.ctx.pluginManager.executeHooks(
+							'pre_llm_call',
+							{ runId: runMgr.id, iteration: iterationNum },
+							this.ctx.emitEvent,
+						)
+						applyLifecycleHookResults('pre_llm_call', hookResults)
+						yield* this.ctx.drainPending()
 					}
 
 					const response = await this.ctx.provider.chat({
@@ -219,10 +226,13 @@ export class IterationOrchestrator {
 					runMgr.accumulateUsage(response.usage)
 
 					if (this.ctx.pluginManager) {
-						await this.ctx.pluginManager.executeHooks('post_llm_call', {
-							runId: runMgr.id,
-							iteration: iterationNum,
-						})
+						const hookResults = await this.ctx.pluginManager.executeHooks(
+							'post_llm_call',
+							{ runId: runMgr.id, iteration: iterationNum },
+							this.ctx.emitEvent,
+						)
+						applyLifecycleHookResults('post_llm_call', hookResults)
+						yield* this.ctx.drainPending()
 					}
 
 					this.ctx.log.debug('LLM response received', {
@@ -357,10 +367,13 @@ export class IterationOrchestrator {
 					await runAdvisoryPhase(this.ctx, iterationNum, response)
 
 					if (this.ctx.pluginManager) {
-						await this.ctx.pluginManager.executeHooks('iteration_end', {
-							runId: runMgr.id,
-							iteration: iterationNum,
-						})
+						const hookResults = await this.ctx.pluginManager.executeHooks(
+							'iteration_end',
+							{ runId: runMgr.id, iteration: iterationNum },
+							this.ctx.emitEvent,
+						)
+						applyLifecycleHookResults('iteration_end', hookResults)
+						yield* this.ctx.drainPending()
 					}
 
 					await this.ctx.emitEvent({

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

@@ -0,0 +1,34 @@
+import type { PluginHookEvent, PluginHookResult } from '../../types/plugin/index.js'
+
+/**
+ * Interpret hook results from non-tool lifecycle events (run_start, run_end,
+ * iteration_start, iteration_end, pre_llm_call, post_llm_call). These contexts
+ * carry no mutable payload, so only `continue` and `error` are meaningful.
+ *
+ * Throws on `error` (propagated to run-failure path) or on action misuse
+ * (skip / modify / retry / resume have no defined contract here).
+ */
+export function applyLifecycleHookResults(
+	event: PluginHookEvent,
+	results: readonly PluginHookResult[],
+): void {
+	for (const result of results) {
+		switch (result.action) {
+			case 'continue':
+				continue
+			case 'error':
+				throw new Error(`Plugin hook ${event} reported error: ${result.message}`)
+			case 'skip':
+			case 'modify':
+			case 'retry':
+			case 'resume':
+				throw new Error(
+					`Plugin hook ${event} returned unsupported action '${result.action}' for a lifecycle event`,
+				)
+			default: {
+				const _exhaustive: never = result
+				throw new Error(`Unknown PluginHookResult: ${JSON.stringify(_exhaustive)}`)
+			}
+		}
+	}
+}

package/src/runtime/query/tooling.ts

@@ -1,3 +1,4 @@
+import type { PluginLifecycleManager } from '../../plugin/lifecycle.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
 import type { RunId } from '../../types/ids/index.js'
 import type { InvocationState } from '../../types/invocation/index.js'
@@ -17,6 +18,7 @@ export interface ToolingBootstrapConfig {
 	env: Record<string, string>
 	abortSignal: AbortSignal
 	invocationState?: InvocationState
+	pluginManager?: PluginLifecycleManager
 }
 
 export class ToolingBootstrap {
@@ -35,6 +37,7 @@ export class ToolingBootstrap {
 				env: config.env,
 				abortSignal: config.abortSignal,
 				invocationState: config.invocationState,
+				pluginManager: config.pluginManager,
 			},
 			activityStore,
 			emitEvent,

package/src/store/index.ts

@@ -1,7 +1,7 @@
 export { InMemoryStore } from './InMemoryStore.js'
 export type { Identifiable, Timestamped } from './InMemoryStore.js'
 
-export { RunDiskStore, SessionStore } from './run/disk.js'
+export { RunDiskStore } from './run/disk.js'
 
 export { ActivityStore } from './activity/memory.js'
 export type { ActivityEvent, ActivityEventListener } from './activity/memory.js'
@@ -12,3 +12,8 @@ export type { DiskTaskStoreConfig } from './task/disk.js'
 
 export { InMemoryConversationStore } from './conversation/memory.js'
 export type { InMemoryConversationStoreConfig } from './conversation/memory.js'
+
+export { InMemoryMemoryIndex } from './memory/index.js'
+export { InMemoryMemoryStore } from './memory/memory.js'
+export { DiskMemoryStore } from './memory/disk.js'
+export type { DiskMemoryStoreConfig } from './memory/disk.js'

package/src/store/run/disk.ts

@@ -217,7 +217,3 @@ async function atomicWriteJson(filePath: string, value: unknown): Promise<void>
 function isFileNotFound(err: unknown): boolean {
 	return typeof err === 'object' && err !== null && (err as NodeJS.ErrnoException).code === 'ENOENT'
 }
-
-export const SessionStore = RunDiskStore
-
-export type SessionStore = RunDiskStore

package/src/store/task/__tests__/disk-concurrency.test.ts

@@ -0,0 +1,118 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { RunId } from '../../../types/ids/index.js'
+import { generateRunId } from '../../../utils/id.js'
+import { DiskTaskStore } from '../disk.js'
+
+describe('DiskTaskStore — concurrency regressions', () => {
+	let baseDir: string
+	let runId: RunId
+	let store: DiskTaskStore
+
+	beforeEach(() => {
+		baseDir = mkdtempSync(join(tmpdir(), 'namzu-task-concurrency-'))
+		runId = generateRunId()
+		store = new DiskTaskStore({ baseDir, defaultRunId: runId })
+	})
+
+	afterEach(() => {
+		rmSync(baseDir, { recursive: true, force: true })
+	})
+
+	it('does not deadlock when two deletes race on mutually-referencing tasks', async () => {
+		const a = await store.create({ runId, subject: 'A' })
+		const b = await store.create({ runId, subject: 'B' })
+
+		// Establish bidirectional edge: A blocks B AND B blocks A.
+		// (Nonsensical semantically, but the store allows it and the lock logic
+		// must not deadlock.)
+		await store.block(a.id, b.id)
+		await store.block(b.id, a.id)
+
+		// Race the two deletes. The pre-fix implementation (lock this → iterate
+		// related → lock each) could acquire A→B from one call and B→A from the
+		// other, deadlocking. withLocks() sorts IDs canonically so both calls
+		// acquire [A, B] in the same order.
+		const withTimeout = <T>(p: Promise<T>, ms: number): Promise<T> =>
+			Promise.race([
+				p,
+				new Promise<never>((_resolve, reject) =>
+					setTimeout(() => reject(new Error('timeout — likely deadlocked')), ms),
+				),
+			])
+
+		const [resA, resB] = await withTimeout(
+			Promise.all([store.delete(a.id), store.delete(b.id)]),
+			2000,
+		)
+		expect(resA).toBe(true)
+		expect(resB).toBe(true)
+		expect(await store.get(a.id)).toBeUndefined()
+		expect(await store.get(b.id)).toBeUndefined()
+	})
+
+	it('serializes concurrent same-ID updates (withLock race regression)', async () => {
+		const task = await store.create({ runId, subject: 'shared' })
+
+		// update()'s metadata merge does `{ ...task.metadata, ...updates.metadata }`
+		// inside withLock. If withLock serializes correctly, every update's key
+		// survives into the final metadata (each sees the latest merged state).
+		// If withLock had the race bug, two concurrent updates would both read
+		// the SAME snapshot, each add their one key, and one update's key would
+		// be overwritten when the second committed — yielding < N keys in the
+		// final metadata.
+		const n = 20
+		await Promise.all(
+			Array.from({ length: n }, (_v, i) =>
+				store.update(task.id, { metadata: { [`k${i}`]: true } }),
+			),
+		)
+
+		const final = await store.get(task.id)
+		const keys = Object.keys(final?.metadata ?? {})
+		expect(keys).toHaveLength(n)
+		for (let i = 0; i < n; i++) {
+			expect(final?.metadata?.[`k${i}`]).toBe(true)
+		}
+	})
+
+	it('establishes bidirectional edge atomically under create()', async () => {
+		const blocker = await store.create({ runId, subject: 'blocker' })
+
+		// Race: create a child with blockedBy=[blocker] while concurrently
+		// deleting the blocker. Either outcome is acceptable (child created
+		// and blocker still present in its blocks list, OR blocker gone and
+		// child created with dangling reference), but we must NEVER see
+		// blocker still present WITHOUT having child in its blocks list.
+		const tasks = await Promise.all([
+			store.create({ runId, subject: 'child', blockedBy: [blocker.id] }),
+			// No delete here — keep the create edge test focused. The point is
+			// that after create() resolves, the blocker's blocks list contains
+			// the new task ID atomically.
+		])
+		const child = tasks[0]
+
+		const blockerAfter = await store.get(blocker.id)
+		expect(blockerAfter).toBeDefined()
+		expect(blockerAfter?.blocks).toContain(child.id)
+		expect(child.blockedBy).toContain(blocker.id)
+	})
+
+	it('block() skips gracefully when one task disappeared before lock acquired', async () => {
+		const a = await store.create({ runId, subject: 'A' })
+		const b = await store.create({ runId, subject: 'B' })
+
+		// Delete B, then try to block a → b. The findTask pre-check passes for a
+		// but fails for b, so block() returns early (silent no-op per existing
+		// contract).
+		await store.delete(b.id)
+
+		// block() should not throw and A's blocks list should remain empty.
+		await store.block(a.id, b.id)
+
+		const aAfter = await store.get(a.id)
+		expect(aAfter?.blocks).not.toContain(b.id)
+	})
+})