@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/executor-concurrency.test.ts

@@ -1,122 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ActivityStore } from '../../../store/activity/memory.js'
-import type { RunId } from '../../../types/ids/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
-}
-
-const delay = (ms: number) => new Promise((r) => setTimeout(r, ms))
-
-/** Two tool calls in one assistant message (one batch). */
-function twoCallResponse(name: string, a: object, b: object): ChatCompletionResponse {
-	return {
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{ id: 'c1', type: 'function', function: { name, arguments: JSON.stringify(a) } },
-				{ id: 'c2', type: 'function', function: { name, arguments: JSON.stringify(b) } },
-			],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-describe('ToolExecutor — concurrencySafe batching', () => {
-	let activityStore: ActivityStore
-	let emitEvent: (e: RunEvent) => Promise<void>
-
-	beforeEach(() => {
-		activityStore = new ActivityStore(mockRunId, {
-			enabled: true,
-			trackToolCalls: true,
-			trackLlmTurns: true,
-		})
-		emitEvent = async () => {}
-	})
-
-	it('serializes concurrency-unsafe tools so read-modify-write does not race', async () => {
-		// Shared mutable state, mutated via read → await → write (like `edit`).
-		let file = 'A'
-		const execute = vi.fn(async (_name: string, input: unknown) => {
-			const current = file // read
-			await delay(10) // window a parallel run would exploit
-			file = current + (input as { add: string }).add // write
-			return { success: true, output: 'ok' }
-		})
-		const tools = {
-			register: vi.fn(),
-			unregister: vi.fn(),
-			execute,
-			// edit/write/bash declare concurrencySafe:false → isConcurrencySafe()=>false
-			get: vi.fn(() => ({ isConcurrencySafe: () => false })),
-			has: vi.fn(() => true),
-			listNames: vi.fn(() => []),
-			getAvailability: vi.fn(),
-		} as unknown as ToolRegistryContract
-
-		const exec = new ToolExecutor(
-			{
-				tools,
-				runId: mockRunId,
-				workingDirectory: '/tmp',
-				permissionMode: 'auto',
-				env: {},
-				abortSignal: new AbortController().signal,
-			},
-			activityStore,
-			emitEvent,
-			makeLogger(),
-		)
-		await exec.executeBatch(twoCallResponse('edit', { add: 'B' }, { add: 'C' }))
-		// Serialized: A→AB→ABC. A racing run would lose one append (e.g. 'AC').
-		expect(file).toBe('ABC')
-	})
-
-	it('runs concurrency-safe tools in parallel', async () => {
-		let active = 0
-		let maxActive = 0
-		const execute = vi.fn(async () => {
-			active++
-			maxActive = Math.max(maxActive, active)
-			await delay(10)
-			active--
-			return { success: true, output: 'ok' }
-		})
-		const tools = {
-			register: vi.fn(),
-			unregister: vi.fn(),
-			execute,
-			get: vi.fn(() => ({ isConcurrencySafe: () => true })),
-			has: vi.fn(() => true),
-			listNames: vi.fn(() => []),
-			getAvailability: vi.fn(),
-		} as unknown as ToolRegistryContract
-
-		const exec = new ToolExecutor(
-			{
-				tools,
-				runId: mockRunId,
-				workingDirectory: '/tmp',
-				permissionMode: 'auto',
-				env: {},
-				abortSignal: new AbortController().signal,
-			},
-			activityStore,
-			emitEvent,
-			makeLogger(),
-		)
-		await exec.executeBatch(twoCallResponse('grep', { p: '1' }, { p: '2' }))
-		expect(maxActive).toBe(2) // both ran at once
-	})
-})

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

@@ -1,354 +0,0 @@
-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('preserves tool stdout/stderr when a tool exits unsuccessfully', async () => {
-		const tools = makeToolRegistry(
-			vi.fn(async () => ({
-				success: false,
-				output: 'STDOUT:\npartial result\n\nSTDERR:\nboom',
-				error: 'Command exited with code 1',
-			})),
-		)
-		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('bash', { command: 'false' }))
-		expect(batch.results[0]?.output).toContain('STDOUT:\npartial result')
-		expect(batch.results[0]?.output).toContain('STDERR:\nboom')
-		expect(batch.results[0]?.output).toContain('Error: Command exited with code 1')
-
-		const completed = emitted.find((e) => e.type === 'tool_completed')
-		expect(completed).toMatchObject({
-			type: 'tool_completed',
-			toolName: 'bash',
-			result: expect.stringContaining('STDOUT:\npartial result'),
-			isError: true,
-		})
-	})
-
-	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(),
-		})
-		// Through the real registration path, so the entries are the ones
-		// dispatch actually receives.
-		realManager.registerHook('p1' as any, {
-			event: 'pre_tool_use',
-			handler: handlers[0] as any,
-		})
-		realManager.registerHook('p2' as any, {
-			event: 'pre_tool_use',
-			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.registerHook('p1' as any, {
-			event: 'pre_tool_use',
-			handler: (async (ctx: any) => {
-				seenInputs.push(['hook1', ctx.toolInput])
-				return { action: 'modify', input: { patched: true } }
-			}) as any,
-		})
-		realManager.registerHook('p2' as any, {
-			event: 'pre_tool_use',
-			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__/finish-reason-vs-tool-calls.test.ts

@@ -1,206 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import { ToolRegistry } from '../../../registry/tool/execute.js'
-import type { SessionId, TenantId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { LLMProvider, StreamChunk } from '../../../types/provider/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/**
- * The turn ended on `finishReason === 'stop'` before it looked at whether
- * the model had asked for tools. Endpoints on the function-calling wire shape —
- * gateways and local servers especially — routinely report `stop` on the
- * same response that carries a populated `tool_calls`, and three of this
- * repo's drivers passed that value through untouched.
- *
- * The damage was total and silent: every requested call skipped, an
- * assistant turn left carrying tool_use blocks nothing ever answered, and
- * the run settling as though it had finished the work.
- *
- * The existing suite could not see it, because the scripted mock reports
- * `tool_calls` whenever it emits one — which is what an honest provider
- * does, and therefore never the case that breaks.
- */
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })))
-})
-
-async function mkWorkdir(): Promise<string> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-finish-'))
-	dirs.push(dir)
-	return dir
-}
-
-const USAGE = {
-	promptTokens: 1,
-	completionTokens: 1,
-	totalTokens: 2,
-	cachedTokens: 0,
-	cacheWriteTokens: 0,
-}
-
-/** Asks for a tool, then claims the turn is over. */
-function provider(reported: 'stop' | 'tool_calls'): LLMProvider {
-	let turn = 0
-	return {
-		id: 'scripted',
-		name: 'scripted',
-		capabilities: {
-			supportsTools: true,
-			supportsStreaming: true,
-			supportsFunctionCalling: true,
-		},
-		async *chatStream(): AsyncIterable<StreamChunk> {
-			turn++
-			if (turn === 1) {
-				yield {
-					id: 'c1',
-					delta: {
-						toolCalls: [
-							{
-								index: 0,
-								id: 'call_1',
-								type: 'function',
-								function: { name: 'echo', arguments: '{"text":"hi"}' },
-							},
-						],
-						toolCallEnd: { index: 0, id: 'call_1' },
-					},
-				}
-				// The lie under test.
-				yield { id: 'c1', delta: {}, finishReason: reported, usage: USAGE }
-				return
-			}
-			yield { id: 'c2', delta: { content: 'done' } }
-			yield { id: 'c2', delta: {}, finishReason: 'stop', usage: USAGE }
-		},
-		async listModels() {
-			return []
-		},
-		async healthCheck() {
-			return true
-		},
-	}
-}
-
-async function run(reported: 'stop' | 'tool_calls') {
-	const tools = new ToolRegistry()
-	let calls = 0
-	tools.register({
-		name: 'echo',
-		description: 'Echo the text back.',
-		inputSchema: z.object({ text: z.string() }),
-		execute: async () => {
-			calls++
-			return { success: true, output: 'ok' }
-		},
-	})
-
-	const result = await drainQuery({
-		provider: provider(reported),
-		tools,
-		messages: [createUserMessage('echo hi')],
-		runConfig: {
-			model: 'scripted-model',
-			timeoutMs: 5_000,
-			tokenBudget: 100_000,
-			maxIterations: 4,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_test',
-		agentName: 'Test Agent',
-		workingDirectory: await mkWorkdir(),
-		sessionId: 'ses_finish' as SessionId,
-		threadId: 'thd_finish' as ThreadId,
-		projectId: 'prj_finish' as ProjectId,
-		tenantId: 'tnt_finish' as TenantId,
-	})
-
-	return { result, calls }
-}
-
-describe('a provider that says stop while asking for a tool', () => {
-	it('runs the tool anyway', async () => {
-		// The calls are the fact and the reason is the summary; when they
-		// disagree the calls win.
-		expect((await run('stop')).calls).toBe(1)
-	})
-
-	it('leaves no tool call unanswered', async () => {
-		const { result } = await run('stop')
-		const requested = result.messages
-			.filter((m) => m.role === 'assistant')
-			.flatMap((m) => (m as { toolCalls?: { id: string }[] }).toolCalls ?? [])
-			.map((c) => c.id)
-		const answered = result.messages
-			.filter((m) => m.role === 'tool')
-			.map((m) => (m as unknown as { toolCallId: string }).toolCallId)
-
-		// An assistant turn carrying a call nothing answered is a malformed
-		// conversation, and the next request is rejected for it.
-		expect(requested.length).toBeGreaterThan(0)
-		for (const id of requested) expect(answered).toContain(id)
-	})
-
-	it('behaves exactly as it does for an honest provider', async () => {
-		const dishonest = await run('stop')
-		const honest = await run('tool_calls')
-		expect(dishonest.calls).toBe(honest.calls)
-		expect(dishonest.result.messages.filter((m) => m.role === 'tool')).toHaveLength(
-			honest.result.messages.filter((m) => m.role === 'tool').length,
-		)
-	})
-
-	it('still ends the turn when there are no tool calls', async () => {
-		const tools = new ToolRegistry()
-		const result = await drainQuery({
-			provider: {
-				id: 'plain',
-				name: 'plain',
-				capabilities: {
-					supportsTools: true,
-					supportsStreaming: true,
-					supportsFunctionCalling: true,
-				},
-				async *chatStream(): AsyncIterable<StreamChunk> {
-					yield { id: 'c', delta: { content: 'just an answer' } }
-					yield { id: 'c', delta: {}, finishReason: 'stop', usage: USAGE }
-				},
-				async listModels() {
-					return []
-				},
-				async healthCheck() {
-					return true
-				},
-			},
-			tools,
-			messages: [createUserMessage('hi')],
-			runConfig: {
-				model: 'plain-model',
-				timeoutMs: 5_000,
-				tokenBudget: 100_000,
-				maxIterations: 4,
-				maxResponseTokens: 256,
-			},
-			agentId: 'agent_test',
-			agentName: 'Test Agent',
-			workingDirectory: await mkWorkdir(),
-			sessionId: 'ses_plain' as SessionId,
-			threadId: 'thd_plain' as ThreadId,
-			projectId: 'prj_plain' as ProjectId,
-			tenantId: 'tnt_plain' as TenantId,
-		})
-
-		// The ordinary path must not have moved.
-		expect(result.status).toBe('completed')
-		expect(result.messages.filter((m) => m.role === 'tool')).toHaveLength(0)
-	})
-})