@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/partial-batch-resume.test.ts

@@ -1,264 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { ActivityStore } from '../../../store/activity/memory.js'
-import { RunDiskStore } from '../../../store/run/disk.js'
-import type { CheckpointId, IterationCheckpoint } from '../../../types/hitl/index.js'
-import type { RunId } from '../../../types/ids/index.js'
-import {
-	type Message,
-	createAssistantMessage,
-	createUserMessage,
-} from '../../../types/message/index.js'
-import type { ToolRegistryContract } from '../../../types/tool/index.js'
-import type { Logger } from '../../../utils/logger.js'
-import { ToolExecutor } from '../executor.js'
-import { planCrashResume, unansweredToolCalls } from '../resume-pending.js'
-
-/**
- * A batch's results reach the history only when the WHOLE batch settles,
- * so a hard kill part-way through loses every result that had already come
- * back — and the resumed run re-executes those calls. For a `write_file`
- * that is waste; for a payment or an email it is a second one.
- *
- * Nothing new had to be recorded to fix it. The executor already awaits a
- * `tool_completed` per tool, inline, carrying the id, the name, the result
- * and the error flag, and the transcript already persists it. The record
- * was durable all along and simply never read back.
- */
-
-function makeLogger(): Logger {
-	const self = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as unknown as Logger
-	;(self as { child: (ctx: unknown) => Logger }).child = vi.fn(() => self)
-	return self
-}
-
-const call = (id: string, name: string) => ({
-	id,
-	type: 'function' as const,
-	function: { name, arguments: '{}' },
-})
-
-function checkpointWith(messages: Message[]): IterationCheckpoint {
-	return { id: 'cp_1' as CheckpointId, messages } as IterationCheckpoint
-}
-
-const parkedBatch = (): Message[] => [
-	createUserMessage('charge the customer and email them'),
-	{
-		...createAssistantMessage(''),
-		toolCalls: [call('t1', 'charge_card'), call('t2', 'send_email')],
-	} as Message,
-]
-
-describe('reading completed calls back out of the transcript', () => {
-	let dir: string
-	let store: RunDiskStore
-
-	beforeEach(async () => {
-		dir = await mkdtemp(join(tmpdir(), 'namzu-resume-'))
-		store = new RunDiskStore({ baseDir: dir })
-		await store.initRun('run_1')
-	})
-
-	afterEach(async () => {
-		await rm(dir, { recursive: true, force: true })
-	})
-
-	const append = async (lines: unknown[]) => {
-		await writeFile(
-			join(dir, 'run_1', 'transcript.jsonl'),
-			`${lines.map((l) => JSON.stringify(l)).join('\n')}\n`,
-			'utf-8',
-		)
-	}
-
-	it('recovers the calls that finished', async () => {
-		await append([
-			{ type: 'tool_executing', toolUseId: 't1', toolName: 'charge_card' },
-			{
-				type: 'tool_completed',
-				toolUseId: 't1',
-				toolName: 'charge_card',
-				result: 'charged',
-				isError: false,
-			},
-		])
-
-		const completed = await store.readCompletedTools()
-		expect(completed.get('t1')).toEqual({
-			toolUseId: 't1',
-			toolName: 'charge_card',
-			result: 'charged',
-			isError: false,
-		})
-		// The one that never finished must NOT be invented — it still has to
-		// run, and claiming otherwise would drop the work silently.
-		expect(completed.has('t2')).toBe(false)
-	})
-
-	it('keeps the last result when a tool was retried', async () => {
-		await append([
-			{
-				type: 'tool_completed',
-				toolUseId: 't1',
-				toolName: 'fetch',
-				result: 'timeout',
-				isError: true,
-			},
-			{ type: 'tool_completed', toolUseId: 't1', toolName: 'fetch', result: 'ok', isError: false },
-		])
-
-		expect((await store.readCompletedTools()).get('t1')?.result).toBe('ok')
-	})
-
-	it('survives the torn last line a killed process leaves behind', async () => {
-		// This is the ordinary shape of a file that was being appended to
-		// when the process died — which is the exact case being recovered.
-		await writeFile(
-			join(dir, 'run_1', 'transcript.jsonl'),
-			`${JSON.stringify({ type: 'tool_completed', toolUseId: 't1', toolName: 'a', result: 'r', isError: false })}\n{"type":"tool_com`,
-			'utf-8',
-		)
-
-		const completed = await store.readCompletedTools()
-		expect(completed.size).toBe(1)
-	})
-
-	it('returns nothing when the run never wrote a transcript', async () => {
-		expect((await store.readCompletedTools()).size).toBe(0)
-	})
-
-	it('ignores an event missing the fields that identify a call', async () => {
-		await append([{ type: 'tool_completed', result: 'orphan', isError: false }])
-		expect((await store.readCompletedTools()).size).toBe(0)
-	})
-})
-
-describe('planning the resume of a part-executed batch', () => {
-	it('takes over when some calls already ran', () => {
-		const messages = parkedBatch()
-		const plan = planCrashResume(checkpointWith(messages), new Map([['t1', {}]]), makeLogger())
-
-		expect(plan).not.toBeNull()
-		// The assistant turn is kept, not stripped: the results about to be
-		// produced have to answer the `tool_use` blocks that are in it.
-		expect(plan?.response.message.toolCalls).toHaveLength(2)
-		expect(plan?.denials.size).toBe(0)
-	})
-
-	it('leaves an untouched batch to the ordinary repair', () => {
-		// A tool-review park records the checkpoint BEFORE any execution, so
-		// nothing completed and re-deciding costs only a round trip. Taking
-		// it over here would execute calls a human had not answered yet.
-		expect(planCrashResume(checkpointWith(parkedBatch()), new Map(), makeLogger())).toBeNull()
-	})
-
-	it('says which calls are about to run for the first time', () => {
-		const log = makeLogger()
-		planCrashResume(checkpointWith(parkedBatch()), new Map([['t1', {}]]), log)
-
-		const warned = (log.warn as unknown as { mock: { calls: unknown[][] } }).mock.calls[0]
-		expect(warned?.[1]).toMatchObject({ completed: 1, total: 2, remaining: ['send_email'] })
-	})
-
-	it('does nothing when the turn is fully answered', () => {
-		const messages: Message[] = [
-			...parkedBatch(),
-			{ role: 'tool', content: 'charged', toolCallId: 't1' } as Message,
-			{ role: 'tool', content: 'sent', toolCallId: 't2' } as Message,
-		]
-		expect(
-			planCrashResume(checkpointWith(messages), new Map([['t1', {}]]), makeLogger()),
-		).toBeNull()
-	})
-})
-
-describe('executing a batch that carries recovered results', () => {
-	const response = {
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [call('t1', 'charge_card'), call('t2', 'send_email')],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as never
-
-	async function runBatch(prior?: ReadonlyMap<string, { result: string; isError: boolean }>) {
-		const execute = vi.fn(async () => ({ success: true, output: 'freshly executed' }))
-		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 executor = new ToolExecutor(
-			{
-				tools,
-				runId: 'run_1' as RunId,
-				workingDirectory: tmpdir(),
-				permissionMode: 'auto',
-				env: {},
-				abortSignal: new AbortController().signal,
-			},
-			new ActivityStore('run_1' as RunId, {
-				enabled: false,
-				trackToolCalls: false,
-				trackLlmTurns: false,
-			}),
-			async () => {},
-			makeLogger(),
-		)
-
-		const batch = await executor.executeBatch(response, undefined, prior)
-		return { batch, execute }
-	}
-
-	it('does not run a tool that already ran', async () => {
-		const { batch, execute } = await runBatch(
-			new Map([['t1', { result: 'charged $40', isError: false }]]),
-		)
-
-		// The whole point: charging the card twice is the failure.
-		expect(execute).toHaveBeenCalledTimes(1)
-		expect(batch.results.find((r) => r.toolCallId === 't1')?.output).toBe('charged $40')
-	})
-
-	it('still runs the calls that never completed', async () => {
-		const { batch } = await runBatch(new Map([['t1', { result: 'charged', isError: false }]]))
-		expect(batch.results.find((r) => r.toolCallId === 't2')?.output).toBe('freshly executed')
-		// Every `tool_use` block is answered, in the original order.
-		expect(batch.results.map((r) => r.toolCallId)).toEqual(['t1', 't2'])
-	})
-
-	it('preserves a recovered failure as a failure', async () => {
-		const { batch } = await runBatch(new Map([['t1', { result: 'declined', isError: true }]]))
-		expect(batch.results.find((r) => r.toolCallId === 't1')?.isError).toBe(true)
-	})
-
-	it('runs everything when nothing was recovered', async () => {
-		const { execute } = await runBatch()
-		expect(execute).toHaveBeenCalledTimes(2)
-	})
-})
-
-describe('which calls are worth asking about', () => {
-	it('is only the unanswered ones', () => {
-		const messages: Message[] = [
-			...parkedBatch(),
-			{ role: 'tool', content: 'charged', toolCallId: 't1' } as Message,
-		]
-		expect(unansweredToolCalls(messages).map((tc) => tc.id)).toEqual(['t2'])
-	})
-
-	it('is empty when the history holds no tool calls at all', () => {
-		expect(unansweredToolCalls([createUserMessage('hello')])).toEqual([])
-	})
-})

package/src/runtime/query/__tests__/per-step-skills.test.ts

@@ -1,154 +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 { MockLLMProvider } from '../../../provider/mock.js'
-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 { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import type { Skill } from '../../../types/skills/index.js'
-import { drainQuery } from '../index.js'
-
-/**
- * A run's skills are fixed at `query()` time and rendered into the cached
- * system prefix, so every skill a run might ever need is paid for on every
- * turn. A phased agent rarely needs them all at once.
- *
- * A peer runtime resolves instructions, model, tools, skills and subagents
- * from context at run time. namzu had the first three; this is the fourth.
- * The fifth is deliberately absent — see the note at the bottom.
- */
-
-let workdirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-function skill(name: string, body?: string): Skill {
-	return {
-		metadata: { name, description: `${name} description` },
-		dirPath: `/skills/${name}`,
-		...(body !== undefined ? { body } : {}),
-	}
-}
-
-async function run(provider: MockLLMProvider, over: Record<string, unknown> = {}): Promise<void> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-skills-'))
-	workdirs.push(dir)
-	await drainQuery({
-		provider,
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 4,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_sk',
-		agentName: 'Skill Agent',
-		workingDirectory: dir,
-		sessionId: 'ses_sk' as SessionId,
-		threadId: 'thd_sk' as ThreadId,
-		projectId: 'prj_sk' as ProjectId,
-		tenantId: 'tnt_sk' as TenantId,
-		messages: [createUserMessage('go')],
-		...over,
-	} as never)
-}
-
-const sent = (provider: MockLLMProvider, index = 0): string =>
-	JSON.stringify(provider.requests.at(index)?.messages ?? [])
-
-describe('a step can put a skill in front of the model', () => {
-	it('renders the skill it named', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-
-		await run(provider, { prepareStep: () => ({ skills: [skill('search-the-web')] }) })
-
-		expect(sent(provider)).toContain('search-the-web')
-	})
-
-	it('sends nothing extra when the step names none', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-
-		await run(provider)
-
-		expect(sent(provider)).not.toContain('Available Skills')
-	})
-
-	it('treats an empty list as naming none', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-
-		await run(provider, { prepareStep: () => ({ skills: [] }) })
-
-		// An empty list is a caller saying "no skills this step", not a
-		// request for an empty section header.
-		expect(sent(provider)).not.toContain('Available Skills')
-	})
-
-	it('carries the step guidance alongside it', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-
-		await run(provider, {
-			prepareStep: () => ({ system: 'You are researching.', skills: [skill('search-the-web')] }),
-		})
-
-		// Both ride the same ephemeral trailing message; neither should
-		// displace the other.
-		const body = sent(provider)
-		expect(body).toContain('You are researching.')
-		expect(body).toContain('search-the-web')
-	})
-})
-
-describe('a step skill does not outlive its step', () => {
-	it('is absent from the next step that does not ask for it', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [] as never, text: 'thinking' }, { text: 'done' }],
-		})
-
-		await run(provider, {
-			prepareStep: ({ stepNumber }: { stepNumber: number }) =>
-				stepNumber === 1 ? { skills: [skill('search-the-web')] } : {},
-		})
-
-		expect(sent(provider, 0)).toContain('search-the-web')
-		if (provider.requests.length > 1) {
-			expect(sent(provider, 1)).not.toContain('search-the-web')
-		}
-	})
-
-	it('does not accumulate across steps', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ text: 'still working' }, { text: 'done' }],
-		})
-
-		await run(provider, {
-			maxIterations: 2,
-			prepareStep: () => ({ skills: [skill('search-the-web')] }),
-		})
-
-		// Appended for the call, never retained. Were it written into the run's
-		// history the section would stack up turn after turn — the same
-		// message repeated, growing the prompt and invalidating the cached
-		// prefix every iteration.
-		const systemCounts = provider.requests.map(
-			(r) => (r.messages ?? []).filter((m) => m.role === 'system').length,
-		)
-		expect(new Set(systemCounts).size).toBe(1)
-	})
-})
-
-/**
- * Sub-agents are deliberately NOT per-step, and this is the note rather than
- * a test that would pretend otherwise. Which agents `create_task` can reach
- * is baked into that tool's input schema, so varying it per step would
- * rebuild the tool catalogue every turn — a worse prompt-cache trade than
- * moving tools around, for a narrowing a step can already express by
- * withholding `create_task` through `activeTools`.
- */

package/src/runtime/query/__tests__/per-step-tool-choice.test.ts

@@ -1,180 +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 { MockLLMProvider } from '../../../provider/mock.js'
-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 { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/**
- * Forcing a tool is the one step-shaping knob that can hang an agent.
- *
- * A forced choice that PERSISTS makes the model call a tool, read the
- * result, and be forced again — forever. The peer SDK that puts
- * `tool_choice` on persistent model settings carries three moving parts to
- * undo that: a tool-use tracker, an opt-out flag, and a reset applied at
- * two separate call sites. Its flag defaults to on precisely because
- * turning it off hangs the agent.
- *
- * Putting the knob on `prepareStep` removes the failure instead of
- * managing it: the next step is prepared from scratch, so a force cannot
- * outlive the step that asked for it. There is no flag to get wrong.
- */
-
-let workdirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-async function mkWorkdir(): Promise<string> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-tool-choice-'))
-	workdirs.push(dir)
-	return dir
-}
-
-function registerEcho(tools: ToolRegistry): void {
-	tools.register({
-		name: 'echo',
-		description: 'Echo the text back.',
-		inputSchema: z.object({ text: z.string().optional() }),
-		execute: async () => ({ success: true, output: 'ok' }),
-	})
-}
-
-async function baseParams(provider: MockLLMProvider, tools: ToolRegistry) {
-	return {
-		provider,
-		tools,
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 4,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_tc',
-		agentName: 'Tool Choice Agent',
-		workingDirectory: await mkWorkdir(),
-		sessionId: 'ses_tc' as SessionId,
-		threadId: 'thd_tc' as ThreadId,
-		projectId: 'prj_tc' as ProjectId,
-		tenantId: 'tnt_tc' as TenantId,
-		messages: [createUserMessage('go')],
-	}
-}
-
-describe('a step can force the model to call a tool', () => {
-	it('puts the caller choice on that step request', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const tools = new ToolRegistry()
-		registerEcho(tools)
-
-		await drainQuery({
-			...(await baseParams(provider, tools)),
-			prepareStep: () => ({ toolChoice: 'required' as const }),
-		})
-
-		expect(provider.requests.at(0)?.toolChoice).toBe('required')
-	})
-
-	it('carries a named function through unchanged', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const tools = new ToolRegistry()
-		registerEcho(tools)
-
-		await drainQuery({
-			...(await baseParams(provider, tools)),
-			prepareStep: () => ({
-				toolChoice: { type: 'function' as const, function: { name: 'echo' } },
-			}),
-		})
-
-		expect(provider.requests.at(0)?.toolChoice).toEqual({
-			type: 'function',
-			function: { name: 'echo' },
-		})
-	})
-
-	it('leaves the request alone when no step asks', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const tools = new ToolRegistry()
-		registerEcho(tools)
-
-		await drainQuery(await baseParams(provider, tools))
-
-		expect(provider.requests.at(0)?.toolChoice).toBeUndefined()
-	})
-
-	it('says nothing when there are no tools to choose between', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-
-		await drainQuery({
-			...(await baseParams(provider, new ToolRegistry())),
-			prepareStep: () => ({ toolChoice: 'required' as const }),
-		})
-
-		// `tool_choice` alongside an absent tool list is rejected by the
-		// providers, so a forced choice with nothing registered has to drop.
-		expect(provider.requests.at(0)?.toolChoice).toBeUndefined()
-	})
-})
-
-/**
- * NOT covered here, and deliberately not faked: the forced-final turn takes
- * precedence over a step's choice (`forceFinalize` wins in
- * `iteration/index.ts`), so a budget-exhausted run can still stop asking
- * for tools and answer. Reaching that branch needs the guard to raise a
- * budget warning, which needs real usage the mock provider does not report.
- * The precedence is implemented and read in review; it is not pinned.
- */
-describe('a forced choice cannot outlive the step that asked for it', () => {
-	it('applies to the named step only, leaving later steps free', async () => {
-		const provider = new MockLLMProvider({
-			turns: [
-				{ toolCalls: [{ id: 'c1', name: 'echo', rawArguments: '{}' }] },
-				{ text: 'finished' },
-			],
-		})
-		const tools = new ToolRegistry()
-		registerEcho(tools)
-
-		await drainQuery({
-			...(await baseParams(provider, tools)),
-			// Only the first step is forced. Without per-step scoping this
-			// would keep forcing and the run would never reach a text answer.
-			prepareStep: ({ stepNumber }) =>
-				stepNumber === 1 ? { toolChoice: 'required' as const } : {},
-		})
-
-		expect(provider.requests.at(0)?.toolChoice).toBe('required')
-		expect(provider.requests.at(1)?.toolChoice).toBeUndefined()
-	})
-
-	it('a run whose every step forces a tool still ends, bounded by the loop', async () => {
-		const provider = new MockLLMProvider({
-			turns: [
-				{ toolCalls: [{ id: 'c1', name: 'echo', rawArguments: '{}' }] },
-				{ toolCalls: [{ id: 'c2', name: 'echo', rawArguments: '{}' }] },
-				{ text: 'finished' },
-			],
-		})
-		const tools = new ToolRegistry()
-		registerEcho(tools)
-
-		const run = await drainQuery({
-			...(await baseParams(provider, tools)),
-			prepareStep: () => ({ toolChoice: 'required' as const }),
-		})
-
-		// The knob cannot hang a run on its own: the iteration cap is still
-		// the backstop, and it settles rather than spinning.
-		expect(['completed', 'failed']).toContain(run.status)
-	})
-})

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

@@ -1,27 +0,0 @@
-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],
-	])('throws on unsupported %s action for lifecycle event', (_, result) => {
-		expect(() => applyLifecycleHookResults('iteration_start', [result])).toThrow(
-			/unsupported action/,
-		)
-	})
-})