@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/prepare-step-chain.test.ts

@@ -1,127 +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 { PrepareStepChain } from '../../../types/run/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/**
- * A single slot is enough for one concern and no help with two. A host
- * with a per-tenant system prefix AND a cost-based model downgrade had to
- * hand-compose them into one callback — which puts the ordering in the
- * host's own code where nothing can see it, and makes each concern's
- * failure the other's problem.
- */
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-async function run(prepareStep: PrepareStepChain) {
-	const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-chain-'))
-	dirs.push(workingDirectory)
-
-	const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-	await drainQuery({
-		provider,
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'base-model',
-			timeoutMs: 10_000,
-			tokenBudget: 100_000,
-			maxIterations: 3,
-			temperature: 0.5,
-		},
-		agentId: 'agent_c',
-		agentName: 'Chained',
-		messages: [createUserMessage('do the work')],
-		workingDirectory,
-		sessionId: 'ses_c' as SessionId,
-		threadId: 'thd_c' as ThreadId,
-		projectId: 'prj_c' as ProjectId,
-		tenantId: 'tnt_c' as TenantId,
-		prepareStep,
-	})
-
-	return provider.requests[0]
-}
-
-describe('several shaping stages', () => {
-	it('applies every stage, so two concerns do not have to be one callback', async () => {
-		const sent = await run([() => ({ model: 'cheap-model' }), () => ({ temperature: 0.1 })])
-
-		expect(sent?.model).toBe('cheap-model')
-		expect(sent?.temperature).toBe(0.1)
-	})
-
-	it('lets a later stage override an earlier one, in declaration order', async () => {
-		// Last writer wins — visibly, because the order is a line in the
-		// host's code rather than an accident of install history.
-		const sent = await run([() => ({ model: 'first' }), () => ({ model: 'second' })])
-
-		expect(sent?.model).toBe('second')
-	})
-
-	it('shows a stage what the ones before it decided', async () => {
-		// Reading the accumulated decision is how a later stage REFINES an
-		// earlier one instead of guessing at it.
-		const seen: unknown[] = []
-		const sent = await run([
-			() => ({ model: 'downgraded' }),
-			(context) => {
-				seen.push(context.prepared)
-				return context.prepared.model === 'downgraded' ? { temperature: 0 } : {}
-			},
-		])
-
-		expect(seen[0]).toMatchObject({ model: 'downgraded' })
-		expect(sent?.temperature).toBe(0)
-	})
-
-	it('starts the first stage with nothing decided', async () => {
-		const seen: unknown[] = []
-		await run([
-			(context) => {
-				seen.push(context.prepared)
-				return {}
-			},
-		])
-
-		expect(seen[0]).toEqual({})
-	})
-
-	it('keeps running the rest when one stage throws', async () => {
-		// One broken concern must not silently disable the others it was
-		// declared beside.
-		const sent = await run([
-			() => {
-				throw new Error('this stage is broken')
-			},
-			() => ({ model: 'still-applied' }),
-		])
-
-		expect(sent?.model).toBe('still-applied')
-	})
-
-	it('still accepts a single function, unchanged', async () => {
-		const sent = await run(() => ({ model: 'solo' }))
-
-		expect(sent?.model).toBe('solo')
-	})
-
-	it('treats an empty list as no shaping at all', async () => {
-		const sent = await run([])
-
-		expect(sent?.model).toBe('base-model')
-		expect(sent?.temperature).toBe(0.5)
-	})
-})

package/src/runtime/query/__tests__/prepare-step.test.ts

@@ -1,233 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it, vi } 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 { PrepareStep } from '../../../types/run/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import type { ToolDefinition } from '../../../types/tool/index.js'
-import { drainQuery } from '../index.js'
-
-/**
- * `stopWhen` let a run decide TO STOP from what its steps produced. This
- * is the other half — deciding how the next step should be SHAPED.
- *
- * Without it the tool surface and the model are fixed at `query()` time,
- * so a phased agent (research with search tools, then write with file
- * tools, then verify with a cheaper model) had to be three separate runs,
- * each starting blind to the last one's context.
- */
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-function tool(name: string, calls: string[]): ToolDefinition {
-	return {
-		name,
-		description: `${name} tool`,
-		inputSchema: z.object({}),
-		execute: () => {
-			calls.push(name)
-			return Promise.resolve({ success: true, output: `${name} ok` })
-		},
-	} as unknown as ToolDefinition
-}
-
-async function run(opts: {
-	turns: NonNullable<ConstructorParameters<typeof MockLLMProvider>[0]>['turns']
-	prepareStep?: PrepareStep
-	toolNames?: string[]
-}) {
-	const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-prepare-'))
-	dirs.push(workingDirectory)
-
-	const calls: string[] = []
-	const tools = new ToolRegistry()
-	for (const name of opts.toolNames ?? ['search', 'write_file']) {
-		tools.register(tool(name, calls))
-	}
-
-	const provider = new MockLLMProvider({ turns: opts.turns })
-	const result = await drainQuery({
-		provider,
-		tools,
-		runConfig: {
-			model: 'base-model',
-			timeoutMs: 10_000,
-			tokenBudget: 100_000,
-			maxIterations: 6,
-			maxResponseTokens: 256,
-			temperature: 0.5,
-		},
-		agentId: 'agent_p',
-		agentName: 'Phased',
-		messages: [createUserMessage('do the work')],
-		workingDirectory,
-		sessionId: 'ses_p' as SessionId,
-		threadId: 'thd_p' as ThreadId,
-		projectId: 'prj_p' as ProjectId,
-		tenantId: 'tnt_p' as TenantId,
-		...(opts.prepareStep ? { prepareStep: opts.prepareStep } : {}),
-	})
-
-	return { result, provider, calls }
-}
-
-describe('prepareStep shapes each step', () => {
-	it('narrows the tool surface for a phase', async () => {
-		const { provider } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: () => ({ activeTools: ['search'] }),
-		})
-
-		const sent = provider.requests[0]?.tools ?? []
-		expect(sent.map((t) => t.function.name)).toEqual(['search'])
-	})
-
-	it('can change the surface between steps', async () => {
-		// The whole point: research first, then write.
-		const { provider } = await run({
-			turns: [{ toolCalls: [{ name: 'search', args: {} }] }, { text: 'written' }],
-			prepareStep: ({ stepNumber }) => ({
-				activeTools: stepNumber === 1 ? ['search'] : ['write_file'],
-			}),
-		})
-
-		expect(provider.requests[0]?.tools?.map((t) => t.function.name)).toEqual(['search'])
-		expect(provider.requests[1]?.tools?.map((t) => t.function.name)).toEqual(['write_file'])
-	})
-
-	it('does NOT touch tool_choice', async () => {
-		// No wire format has an `allowed_tools` parameter, and moving `tool_choice`
-		// invalidates cached MESSAGE blocks too — a strictly worse trade for
-		// the same effect.
-		const { provider } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: () => ({ activeTools: ['search'] }),
-		})
-		expect(provider.requests[0]?.toolChoice).toBeUndefined()
-	})
-
-	it('overrides the model for one step', async () => {
-		const { provider } = await run({
-			turns: [{ toolCalls: [{ name: 'search', args: {} }] }, { text: 'done' }],
-			prepareStep: ({ stepNumber }) => (stepNumber === 2 ? { model: 'cheap-model' } : undefined),
-		})
-
-		expect(provider.requests[0]?.model).toBe('base-model')
-		expect(provider.requests[1]?.model).toBe('cheap-model')
-	})
-
-	it('overrides sampling for one step', async () => {
-		const { provider } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: () => ({ temperature: 0, maxResponseTokens: 64 }),
-		})
-
-		expect(provider.requests[0]?.temperature).toBe(0)
-		expect(provider.requests[0]?.maxTokens).toBe(64)
-	})
-
-	it('adds step guidance to the REQUEST without retaining it in history', async () => {
-		// Pushing it onto the run would accumulate one stale instruction per
-		// iteration.
-		const { provider, result } = await run({
-			turns: [{ toolCalls: [{ name: 'search', args: {} }] }, { text: 'done' }],
-			prepareStep: ({ stepNumber }) =>
-				stepNumber === 1 ? { system: 'PHASE: research only' } : undefined,
-		})
-
-		const first = provider.requests[0]?.messages ?? []
-		expect(JSON.stringify(first)).toContain('PHASE: research only')
-
-		// Not in the second request, and not in the run's history.
-		expect(JSON.stringify(provider.requests[1]?.messages ?? [])).not.toContain('PHASE:')
-		expect(JSON.stringify(result.messages)).not.toContain('PHASE:')
-	})
-
-	it('sees the steps produced so far', async () => {
-		const seen: number[] = []
-		await run({
-			turns: [{ toolCalls: [{ name: 'search', args: {} }] }, { text: 'done' }],
-			prepareStep: ({ stepNumber, steps, messages }) => {
-				seen.push(steps.length)
-				expect(stepNumber).toBe(seen.length)
-				expect(messages.length).toBeGreaterThan(0)
-				return undefined
-			},
-		})
-
-		// Step 1 has nothing behind it; step 2 can read step 1's result.
-		expect(seen).toEqual([0, 1])
-	})
-})
-
-describe('prepareStep is safe to get wrong', () => {
-	it('fails OPEN — a throwing hook does not kill a healthy run', async () => {
-		// Same reasoning as `stopWhen`, and deliberately opposite to a
-		// guardrail: nothing unsafe gets through when step shaping is
-		// skipped.
-		const { result, provider } = await run({
-			turns: [{ text: 'still fine' }],
-			prepareStep: () => {
-				throw new Error('phase table missing')
-			},
-		})
-
-		expect(result.result).toBe('still fine')
-		expect(result.stopReason).toBe('end_turn')
-		// Fell back to the run's full surface.
-		expect(provider.requests[0]?.tools).toHaveLength(2)
-	})
-
-	it('ignores tools that are not registered rather than failing the run', async () => {
-		// A phase list that outlives a tool rename should narrow the
-		// surface, not kill the agent mid-run.
-		const { provider, result } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: () => ({ activeTools: ['search', 'renamed_away'] }),
-		})
-
-		expect(provider.requests[0]?.tools?.map((t) => t.function.name)).toEqual(['search'])
-		expect(result.stopReason).toBe('end_turn')
-	})
-
-	it('returning nothing is the same as having no hook', async () => {
-		const hook = vi.fn<PrepareStep>(() => undefined)
-		const { provider } = await run({ turns: [{ text: 'done' }], prepareStep: hook })
-
-		expect(hook).toHaveBeenCalled()
-		expect(provider.requests[0]?.model).toBe('base-model')
-		expect(provider.requests[0]?.temperature).toBe(0.5)
-		expect(provider.requests[0]?.tools).toHaveLength(2)
-	})
-
-	it('an empty activeTools list really does remove every tool', async () => {
-		// Distinguished from "no opinion" — `[]` is a decision.
-		const { provider } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: () => ({ activeTools: [] }),
-		})
-		expect(provider.requests[0]?.tools).toBeUndefined()
-	})
-
-	it('an async hook is awaited', async () => {
-		const { provider } = await run({
-			turns: [{ text: 'done' }],
-			prepareStep: async () => {
-				await Promise.resolve()
-				return { model: 'async-model' }
-			},
-		})
-		expect(provider.requests[0]?.model).toBe('async-model')
-	})
-})

package/src/runtime/query/__tests__/probe-veto-is-error.test.ts

@@ -1,145 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { createProbeRegistry } from '../../../probe/registry.js'
-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'
-
-/**
- * The probe-veto branch was the only result-producing branch in the
- * executor that left `isError` off, and `isError` being optional meant the
- * compiler could not notice. Five lines above it, the `tool_completed`
- * event for the same veto carried `isError: true` — so the run's event
- * stream and the result it returned disagreed about the same call, in the
- * same function.
- *
- * Four things degraded off that one omission, which is why a one-word fix
- * is worth a file of tests: two drivers emit their failure marker only when
- * this is true, so the model read a SUCCESSFUL result whose body begins
- * "Error: …" and its trained failure-recovery path never fired; the
- * persisted step recorded a literal `isError: false`; and compaction's
- * guard against clearing error results silently excluded vetoed ones.
- */
-
-const RUN_ID = 'run_veto' 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(): ToolRegistryContract {
-	return {
-		register: vi.fn(),
-		unregister: vi.fn(),
-		execute: vi.fn(async () => ({ success: true, output: 'should never run' })),
-		get: vi.fn(() => undefined),
-		has: vi.fn(() => true),
-		listNames: vi.fn(() => []),
-		getAvailability: vi.fn(),
-	} as unknown as ToolRegistryContract
-}
-
-function response(): ChatCompletionResponse {
-	return {
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{
-					id: 'call_1',
-					type: 'function',
-					function: { name: 'write', arguments: '{"path":"/etc/passwd"}' },
-				},
-			],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-describe('a tool call a probe vetoed', () => {
-	let emitted: RunEvent[]
-	let executor: ToolExecutor
-
-	beforeEach(() => {
-		emitted = []
-		const probes = createProbeRegistry()
-		probes.veto('tool_executing', () => ({ action: 'deny', reason: 'outside workspace' }), {
-			name: 'sandbox',
-		})
-
-		executor = new ToolExecutor(
-			{
-				tools: makeToolRegistry(),
-				runId: RUN_ID,
-				workingDirectory: '/tmp',
-				permissionMode: 'auto',
-				env: {},
-				abortSignal: new AbortController().signal,
-			},
-			new ActivityStore(RUN_ID, { enabled: true, trackToolCalls: true, trackLlmTurns: true }),
-			async (e: RunEvent) => {
-				emitted.push(e)
-			},
-			makeLogger(),
-			probes,
-		)
-	})
-
-	it('returns a result marked as an error', async () => {
-		const batch = await executor.executeBatch(response())
-		// Without this the model reads a successful result whose body begins
-		// "Error: …", and the failure-recovery path it was trained on never
-		// fires.
-		expect(batch.results[0]?.isError).toBe(true)
-	})
-
-	it('agrees with the event it emitted for the same call', async () => {
-		const batch = await executor.executeBatch(response())
-		const completed = emitted.find((e) => e.type === 'tool_completed') as
-			| { isError?: boolean }
-			| undefined
-
-		// These are produced five lines apart in the same function and
-		// described the same call differently.
-		expect(completed?.isError).toBe(true)
-		expect(batch.results[0]?.isError).toBe(completed?.isError)
-	})
-
-	it('still explains itself in the output text', async () => {
-		const batch = await executor.executeBatch(response())
-		expect(batch.results[0]?.output).toContain('outside workspace')
-	})
-
-	it('never ran the tool', async () => {
-		const batch = await executor.executeBatch(response())
-		expect(batch.results[0]?.output).not.toContain('should never run')
-	})
-
-	it('leaves an allowed call unmarked', async () => {
-		const probes = createProbeRegistry()
-		const allowed = new ToolExecutor(
-			{
-				tools: makeToolRegistry(),
-				runId: RUN_ID,
-				workingDirectory: '/tmp',
-				permissionMode: 'auto',
-				env: {},
-				abortSignal: new AbortController().signal,
-			},
-			new ActivityStore(RUN_ID, { enabled: true, trackToolCalls: true, trackLlmTurns: true }),
-			async () => {},
-			makeLogger(),
-			probes,
-		)
-
-		const batch = await allowed.executeBatch(response())
-		// The ordinary path must not have moved.
-		expect(batch.results[0]?.isError).toBeFalsy()
-	})
-})

package/src/runtime/query/__tests__/prompt.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import type { ToolRegistryContract } from '../../../types/tool/index.js'
-import { PromptBuilder } from '../prompt.js'
-
-function makeToolRegistry(): ToolRegistryContract {
-	return {
-		register: vi.fn(),
-		unregister: vi.fn(),
-		execute: vi.fn(),
-		get: vi.fn(() => undefined),
-		has: vi.fn(() => false),
-		listNames: vi.fn(() => []),
-		getAvailability: vi.fn(),
-		toPromptSection: vi.fn(() => ''),
-		toTierGuidance: vi.fn(() => ''),
-	} as unknown as ToolRegistryContract
-}
-
-describe('PromptBuilder runtime context', () => {
-	it('includes output contract even when no filesystem tool is registered', () => {
-		const prompt = new PromptBuilder({
-			systemPrompt: 'You are a worker.',
-			tools: makeToolRegistry(),
-			runtimeContext: {
-				label: 'test runtime',
-				outputDirectory: 'outputs/',
-				outputFileMarker: 'OUTPUT_FILE: <filename> - <description>',
-				notes: ['Register generated files after the turn.'],
-			},
-		}).build('full', '/tmp/work')
-
-		expect(prompt).toContain('Runtime: test runtime')
-		expect(prompt).toContain('Working directory: /tmp/work')
-		expect(prompt).toContain('Output directory: outputs/')
-		expect(prompt).toContain('OUTPUT_FILE: <filename> - <description>')
-		expect(prompt).toContain('Register generated files after the turn.')
-	})
-
-	it('discloses available skills even when the host supplies a systemPrompt', () => {
-		const prompt = new PromptBuilder({
-			systemPrompt: 'You are a project assistant.',
-			tools: makeToolRegistry(),
-			skills: [
-				{
-					metadata: {
-						name: 'delivery-briefing',
-						description: 'Draft and edit delivery briefings from grounded inputs.',
-					},
-					dirPath: '/repo/.agents/skills/delivery-briefing',
-				},
-			],
-		}).build('full', '/tmp/work')
-
-		expect(prompt).toContain('You are a project assistant.')
-		expect(prompt).toContain('## Available Skills')
-		expect(prompt).toContain('<available_skills>')
-		expect(prompt).toContain('delivery-briefing')
-		expect(prompt).toContain('Draft and edit delivery briefings')
-		expect(prompt).toContain('<location>/repo/.agents/skills/delivery-briefing/SKILL.md</location>')
-		expect(prompt).toContain('The following block is a manifest')
-		expect(prompt).not.toContain('## Loaded Skills')
-	})
-
-	it('includes loaded skill bodies with systemPrompt while preserving the metadata catalogue', () => {
-		const prompt = new PromptBuilder({
-			systemPrompt: 'You are a supervisor.',
-			tools: makeToolRegistry(),
-			skills: [
-				{
-					metadata: {
-						name: 'structured-file-authoring',
-						description: 'Create structured files with bounded edit chunks.',
-						license: 'MIT',
-						compatibility: 'Requires file tools',
-						allowedTools: 'read write edit',
-					},
-					body: 'Use skeleton-first writes and bounded edit chunks.',
-					dirPath: '/repo/.agents/skills/structured-file-authoring',
-				},
-			],
-		}).build('full', '/tmp/work')
-
-		expect(prompt).toContain('## Available Skills')
-		expect(prompt).toContain('<license>MIT</license>')
-		expect(prompt).toContain('<compatibility>Requires file tools</compatibility>')
-		expect(prompt).toContain('<allowed_tools>read write edit</allowed_tools>')
-		expect(prompt).toContain('read the SKILL.md at its <location> before writing code')
-		expect(prompt).toContain('## Loaded Skills')
-		expect(prompt).toContain('Use skeleton-first writes')
-	})
-})