@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/a-settled-plan-reaches-the-host.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { PlanManager } from '../../../manager/plan/lifecycle.js'
-import { MockLLMProvider, registerMock } from '../../../provider/index.js'
-import { ToolRegistry } from '../../../registry/index.js'
-import type { RunEvent } from '../../../types/run/index.js'
-import {
-	generateProjectId,
-	generateSessionId,
-	generateTenantId,
-	generateThreadId,
-} from '../../../utils/id.js'
-import { drainQuery } from '../index.js'
-
-/**
- * The plan stream stopped one event short of the outcome.
- *
- * `plan_ready`, `plan_approved`, `plan_rejected` and `plan_step_updated` all
- * reached the wire; `plan.completed` and `plan.failed` were folded into a bare
- * `break` in the translator and emitted nothing. So a host watching the stream
- * saw the steps report and then silence — it could learn a plan had been
- * approved and never that it closed, which leaves a plan rendered as in-flight
- * indefinitely.
- *
- * **This was found by a live end-to-end run, not by a test, and that is the
- * point worth keeping.** The settlement tests read the outcome off
- * `PlanManager` through `onContextCreated`, so they proved the plan settled
- * without ever asking whether a consumer of the EVENT STREAM could see it. A
- * verification can be entirely sound about a thing that is no longer the thing
- * you need to know.
- */
-
-registerMock()
-
-async function runWithPlan(seed: (pm: PlanManager) => void): Promise<RunEvent[]> {
-	const events: RunEvent[] = []
-
-	await drainQuery(
-		{
-			provider: new MockLLMProvider({ responses: [{ content: 'done' }] } as never),
-			tools: new ToolRegistry(),
-			agentId: 'a',
-			agentName: 'A',
-			messages: [{ role: 'user', content: 'go' }],
-			workingDirectory: process.cwd(),
-			runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 4 },
-			projectId: generateProjectId(),
-			sessionId: generateSessionId(),
-			threadId: generateThreadId(),
-			tenantId: generateTenantId(),
-			onContextCreated: ({ planManager }: { planManager: PlanManager }) => seed(planManager),
-		} as never,
-		(event: RunEvent) => {
-			events.push(event)
-		},
-	)
-
-	return events
-}
-
-function twoStepPlan(pm: PlanManager): void {
-	pm.startGenerating('the work')
-	pm.addStep({ id: 'step_1', description: 'first', dependsOn: [], order: 1 })
-	pm.addStep({ id: 'step_2', description: 'second', dependsOn: [], order: 2 })
-	pm.markReady()
-	pm.approve()
-	pm.startExecution()
-}
-
-const typesOf = (events: RunEvent[]) => events.map((e) => e.type)
-
-describe('a settled plan says so on the run stream', () => {
-	it('emits plan_completed when the run settles a successful plan', async () => {
-		const events = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-			p.updateStepStatus('step_2', 'skipped')
-		})
-
-		expect(typesOf(events)).toContain('plan_completed')
-	})
-
-	it('emits plan_failed, carrying the reason failPlan was given', async () => {
-		// `failPlan` took this argument and discarded it — the parameter was
-		// spelled `_error`. An event that says "failed" without saying why puts
-		// the reader back where the missing event did.
-		const events = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.failPlan('the provider refused the request')
-		})
-
-		const failed = events.find((e) => e.type === 'plan_failed')
-		expect(failed).toBeDefined()
-		expect((failed as { reason?: string }).reason).toBe('the provider refused the request')
-	})
-
-	it('emits plan_failed when a step actually failed', async () => {
-		const events = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-			p.updateStepStatus('step_2', 'failed')
-		})
-
-		expect(typesOf(events)).toContain('plan_failed')
-		expect(typesOf(events)).not.toContain('plan_completed')
-	})
-
-	it('says nothing terminal while a step has not reported', async () => {
-		// The plan is genuinely unsettled, so the silence here is correct — it
-		// is the silence AFTER settlement that was the defect.
-		const events = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-		})
-
-		expect(typesOf(events)).not.toContain('plan_completed')
-		expect(typesOf(events)).not.toContain('plan_failed')
-		// ...and the step that DID report is still announced, so this is not a
-		// stream that has simply gone quiet.
-		expect(typesOf(events)).toContain('plan_step_updated')
-	})
-})

package/src/runtime/query/__tests__/answer-review.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { MockLLMProvider, registerMock } from '../../../provider/index.js'
-import { ToolRegistry } from '../../../registry/index.js'
-import type { AnswerReview } from '../../../types/run/answer-review.js'
-import {
-	generateProjectId,
-	generateSessionId,
-	generateTenantId,
-	generateThreadId,
-} from '../../../utils/id.js'
-import { drainQuery } from '../index.js'
-
-/**
- * The halt predicate is only consulted after tools have run, so there was
- * no seam at the point the model stops calling them: the run finalized
- * with whatever it had produced. Verify-then-fix — run the build, feed the
- * failure back, let it try again — meant starting a whole new run and
- * re-supplying the context the first one had already assembled.
- */
-
-registerMock()
-
-function scriptedRun(
-	replies: readonly string[],
-	reviewAnswer: (answer: string) => AnswerReview | Promise<AnswerReview>,
-	maxAnswerReviews?: number,
-) {
-	let turn = 0
-	const provider = new MockLLMProvider({
-		responses: replies.map((content) => ({ content })),
-	} as never)
-	// The mock cycles its scripted replies; the counter is what lets a test
-	// assert how many turns the loop actually took.
-	const original = provider.chatStream.bind(provider)
-	provider.chatStream = ((params: never) => {
-		turn++
-		return original(params)
-	}) as typeof provider.chatStream
-
-	return {
-		turns: () => turn,
-		run: () =>
-			drainQuery({
-				provider,
-				tools: new ToolRegistry(),
-				agentId: 'a',
-				agentName: 'A',
-				messages: [{ role: 'user', content: 'go' }],
-				workingDirectory: process.cwd(),
-				runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 10 },
-				projectId: generateProjectId(),
-				sessionId: generateSessionId(),
-				threadId: generateThreadId(),
-				tenantId: generateTenantId(),
-				reviewAnswer: (answer: string) => reviewAnswer(answer),
-				...(maxAnswerReviews !== undefined ? { maxAnswerReviews } : {}),
-			} as never),
-	}
-}
-
-describe('judging the answer a run is about to settle with', () => {
-	it('accepts and settles without an extra turn', async () => {
-		const review = vi.fn(() => ({ accept: true }) as AnswerReview)
-		const scripted = scriptedRun(['the answer'], review)
-
-		await scripted.run()
-
-		expect(review).toHaveBeenCalledTimes(1)
-		expect(scripted.turns()).toBe(1)
-	})
-
-	it('hands a rejected answer back and runs another turn', async () => {
-		// The whole point: the model gets another go WITH the context it
-		// already has, instead of the host starting a fresh run.
-		let calls = 0
-		const scripted = scriptedRun(['first', 'second'], () => {
-			calls++
-			return calls === 1 ? { accept: false, feedback: 'the build fails' } : { accept: true }
-		})
-
-		await scripted.run()
-		expect(scripted.turns()).toBe(2)
-	})
-
-	it('sends the feedback as the next user turn', async () => {
-		let seen: string | undefined
-		let calls = 0
-		const provider = new MockLLMProvider({ responses: [{ content: 'x' }] } as never)
-		const original = provider.chatStream.bind(provider)
-		provider.chatStream = ((params: { messages: { role: string; content: string }[] }) => {
-			const last = params.messages[params.messages.length - 1]
-			if (calls > 0) seen = last?.content
-			calls++
-			return original(params as never)
-		}) as typeof provider.chatStream
-
-		await drainQuery({
-			provider,
-			tools: new ToolRegistry(),
-			agentId: 'a',
-			agentName: 'A',
-			messages: [{ role: 'user', content: 'go' }],
-			workingDirectory: process.cwd(),
-			runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 4 },
-			projectId: generateProjectId(),
-			sessionId: generateSessionId(),
-			threadId: generateThreadId(),
-			tenantId: generateTenantId(),
-			reviewAnswer: () =>
-				calls === 1 ? { accept: false, feedback: 'FIX: tests red' } : { accept: true },
-		} as never)
-
-		// Prose, and in the slot the model reads — a code would have to be
-		// explained to it anyway.
-		expect(seen).toBe('FIX: tests red')
-	})
-
-	it('stops with a reason that names the reviewer, not a budget', async () => {
-		// A reviewer that never accepts would otherwise burn the whole token
-		// budget and end on `max_iterations`, sending the reader to look for
-		// a loop instead of at the reviewer.
-		const scripted = scriptedRun(['a'], () => ({ accept: false, feedback: 'no' }), 2)
-		const run = await scripted.run()
-
-		expect(run.stopReason).toBe('answer_rejected')
-	})
-
-	it('spends only the attempts it was given', async () => {
-		const review = vi.fn(() => ({ accept: false, feedback: 'no' }) as AnswerReview)
-		const scripted = scriptedRun(['a'], review, 2)
-		await scripted.run()
-
-		// Two rejections, then the third call is the one that exceeds the
-		// limit and stops the run.
-		expect(review).toHaveBeenCalledTimes(3)
-	})
-
-	it('accepts when the reviewer throws, and does not loop', async () => {
-		// The opposite of what the safety gates do, deliberately. Those are
-		// asked "is this dangerous", where failing closed costs one refused
-		// operation. This is asked "is this good enough", where failing
-		// closed means handing the answer back forever.
-		const scripted = scriptedRun(['a'], () => {
-			throw new Error('reviewer exploded')
-		})
-
-		const run = await scripted.run()
-		expect(run.stopReason).not.toBe('answer_rejected')
-		expect(scripted.turns()).toBe(1)
-	})
-
-	it('is not consulted at all when no reviewer was supplied', async () => {
-		const provider = new MockLLMProvider({ responses: [{ content: 'done' }] } as never)
-		const run = await drainQuery({
-			provider,
-			tools: new ToolRegistry(),
-			agentId: 'a',
-			agentName: 'A',
-			messages: [{ role: 'user', content: 'go' }],
-			workingDirectory: process.cwd(),
-			runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 4 },
-			projectId: generateProjectId(),
-			sessionId: generateSessionId(),
-			threadId: generateThreadId(),
-			tenantId: generateTenantId(),
-		} as never)
-
-		// The default path must be byte-identical for every existing caller.
-		expect(run.stopReason).not.toBe('answer_rejected')
-	})
-})

package/src/runtime/query/__tests__/capability-negotiation.test.ts

@@ -1,301 +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 {
-	PERMISSIVE_PROVIDER_CAPABILITIES,
-	resolveProviderCapabilities,
-} from '../../../provider/capabilities.js'
-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 { LLMProvider, ProviderCapabilities } from '../../../types/provider/index.js'
-import type { RunEvent } from '../../../types/run/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/**
- * The scriptable mock captures every request and now accepts a capability
- * override, which is the whole reason this suite had a bespoke class: a
- * fixed registry-level declaration cannot express "a driver with no
- * vision".
- */
-function capturingProvider(capabilities?: ProviderCapabilities): MockLLMProvider {
-	return new MockLLMProvider({
-		turns: [{ text: 'done' }],
-		...(capabilities ? { capabilities } : {}),
-	})
-}
-
-const NO_TOOLS_CAPABILITIES: ProviderCapabilities = {
-	supportsTools: false,
-	supportsStreaming: true,
-	supportsFunctionCalling: false,
-	supportsVision: true,
-}
-
-const NO_VISION_CAPABILITIES: ProviderCapabilities = {
-	supportsTools: true,
-	supportsStreaming: true,
-	supportsFunctionCalling: true,
-	supportsVision: false,
-}
-
-/**
- * A tool that opts in to constrained generation, which is the only thing
- * that makes `enforceToolInputSchema` non-empty on the wire.
- */
-function registerEnforcedTool(tools: ToolRegistry, name: string): void {
-	tools.register({
-		name,
-		description: `${name} tool`,
-		inputSchema: z.object({ new_string: z.string().optional(), newStr: z.string().optional() }),
-		modelInputSchema: {
-			type: 'object',
-			properties: { new_string: { type: 'string' } },
-			required: ['new_string'],
-			additionalProperties: false,
-		},
-		enforceModelInput: true,
-		execute: async () => ({ success: true, output: 'ok' }),
-	})
-}
-
-function registerEchoTool(tools: ToolRegistry): void {
-	tools.register({
-		name: 'echo',
-		description: 'Echo the text back.',
-		inputSchema: z.object({ text: z.string() }),
-		execute: async () => ({ success: true, output: 'ok' }),
-	})
-}
-
-function baseParams(provider: LLMProvider, tools: ToolRegistry, workingDirectory: string) {
-	return {
-		provider,
-		tools,
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 5_000,
-			tokenBudget: 100_000,
-			maxIterations: 1,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_test',
-		agentName: 'Test Agent',
-		workingDirectory,
-		sessionId: 'ses_capability' as SessionId,
-		threadId: 'thd_capability' as ThreadId,
-		projectId: 'prj_capability' as ProjectId,
-		tenantId: 'tnt_capability' as TenantId,
-	}
-}
-
-describe('resolveProviderCapabilities', () => {
-	it('resolves an undeclared provider to the permissive default', () => {
-		expect(resolveProviderCapabilities(capturingProvider())).toEqual(
-			PERMISSIVE_PROVIDER_CAPABILITIES,
-		)
-	})
-
-	it('fills a partial declaration (missing supportsVision) permissively per field', () => {
-		const resolved = resolveProviderCapabilities({
-			capabilities: {
-				supportsTools: false,
-				supportsStreaming: true,
-				supportsFunctionCalling: false,
-			},
-		})
-		expect(resolved.supportsTools).toBe(false)
-		expect(resolved.supportsVision).toBe(true)
-	})
-})
-
-describe('query() capability negotiation', () => {
-	let workdirs: string[] = []
-
-	afterEach(async () => {
-		await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })))
-		workdirs = []
-	})
-
-	async function mkWorkdir(): Promise<string> {
-		const dir = await mkdtemp(join(tmpdir(), 'namzu-capability-'))
-		workdirs.push(dir)
-		return dir
-	}
-
-	it('strips tool surfaces and emits a capability_warning for a no-tools provider', async () => {
-		const provider = capturingProvider(NO_TOOLS_CAPABILITIES)
-		const tools = new ToolRegistry()
-		registerEchoTool(tools)
-		const events: RunEvent[] = []
-
-		const run = await drainQuery(
-			{
-				...baseParams(provider, tools, await mkWorkdir()),
-				messages: [createUserMessage('hello')],
-			},
-			(event) => {
-				events.push(event)
-			},
-		)
-
-		expect(run.status).toBe('completed')
-
-		// The model was never told about tools: no tools param on the wire…
-		expect(provider.requests.at(-1)?.tools).toBeUndefined()
-		// …and no tool section in the system prompt.
-		const systemPrompt = (provider.requests.at(-1)?.messages ?? [])
-			.filter((m) => m.role === 'system')
-			.map((m) => m.content)
-			.join('\n')
-		expect(systemPrompt).not.toContain('<available_tools>')
-		expect(systemPrompt).not.toContain('echo')
-
-		// The host got the machine-readable warning.
-		const warning = events.find(
-			(e): e is Extract<RunEvent, { type: 'capability_warning' }> =>
-				e.type === 'capability_warning',
-		)
-		expect(warning?.capability).toBe('tools')
-		expect(warning?.providerId).toBe(provider.id)
-		expect(warning?.message).toContain('stripped')
-	})
-
-	it('keeps tool surfaces intact for an undeclared (permissive-default) provider', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerEchoTool(tools)
-
-		const run = await drainQuery({
-			...baseParams(provider, tools, await mkWorkdir()),
-			messages: [createUserMessage('hello')],
-		})
-
-		expect(run.status).toBe('completed')
-		expect(provider.requests.at(-1)?.tools?.map((t) => t.function.name)).toContain('echo')
-	})
-
-	it('emits a vision capability_warning when attachments hit a no-vision provider', async () => {
-		const provider = capturingProvider(NO_VISION_CAPABILITIES)
-		const events: RunEvent[] = []
-
-		const run = await drainQuery(
-			{
-				...baseParams(provider, new ToolRegistry(), await mkWorkdir()),
-				messages: [
-					createUserMessage('what is in this image?', [
-						{ data: 'aGVsbG8=', mediaType: 'image/png' },
-					]),
-				],
-			},
-			(event) => {
-				events.push(event)
-			},
-		)
-
-		expect(run.status).toBe('completed')
-		const warning = events.find(
-			(e): e is Extract<RunEvent, { type: 'capability_warning' }> =>
-				e.type === 'capability_warning',
-		)
-		expect(warning?.capability).toBe('vision')
-		expect(warning?.providerId).toBe(provider.id)
-	})
-
-	it('does not warn when no attachments are present on a no-vision provider', async () => {
-		const provider = capturingProvider(NO_VISION_CAPABILITIES)
-		const events: RunEvent[] = []
-
-		await drainQuery(
-			{
-				...baseParams(provider, new ToolRegistry(), await mkWorkdir()),
-				messages: [createUserMessage('plain text')],
-			},
-			(event) => {
-				events.push(event)
-			},
-		)
-
-		expect(events.some((e) => e.type === 'capability_warning')).toBe(false)
-	})
-
-	it('strictCapabilities: true throws on a tools mismatch instead of degrading', async () => {
-		const provider = capturingProvider(NO_TOOLS_CAPABILITIES)
-		const tools = new ToolRegistry()
-		registerEchoTool(tools)
-
-		await expect(
-			drainQuery({
-				...baseParams(provider, tools, await mkWorkdir()),
-				messages: [createUserMessage('hello')],
-				strictCapabilities: true,
-			}),
-		).rejects.toThrow(/supportsTools: false/)
-	})
-
-	it('strictCapabilities: true throws on a vision mismatch instead of degrading', async () => {
-		const provider = capturingProvider(NO_VISION_CAPABILITIES)
-
-		await expect(
-			drainQuery({
-				...baseParams(provider, new ToolRegistry(), await mkWorkdir()),
-				messages: [createUserMessage('describe', [{ data: 'aGVsbG8=', mediaType: 'image/png' }])],
-				strictCapabilities: true,
-			}),
-		).rejects.toThrow(/supportsVision: false/)
-	})
-
-	it('names the enforced tools on the request, so a driver can constrain them', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerEnforcedTool(tools, 'edit')
-		registerEnforcedTool(tools, 'write')
-		registerEchoTool(tools)
-
-		const run = await drainQuery({
-			...baseParams(provider, tools, await mkWorkdir()),
-			messages: [createUserMessage('hello')],
-		})
-
-		expect(run.status).toBe('completed')
-		// The producer was deleted, so this was undefined on every request and
-		// the three drivers that read it were reading a field nothing ever
-		// set — `enforceModelInput` on a tool meant nothing end to end.
-		expect(provider.requests.at(-1)?.enforceToolInputSchema).toEqual(['edit', 'write'])
-	})
-
-	it('omits the field entirely when no tool opts in', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerEchoTool(tools)
-
-		await drainQuery({
-			...baseParams(provider, tools, await mkWorkdir()),
-			messages: [createUserMessage('hello')],
-		})
-
-		// An empty array would read as "enforce nothing" rather than "nothing
-		// asked", and a driver cannot tell those two apart.
-		expect(provider.requests.at(-1)?.enforceToolInputSchema).toBeUndefined()
-	})
-
-	it('follows the allowed set rather than everything registered', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerEnforcedTool(tools, 'edit')
-		registerEnforcedTool(tools, 'excluded')
-
-		await drainQuery({
-			...baseParams(provider, tools, await mkWorkdir()),
-			allowedTools: ['edit'],
-			messages: [createUserMessage('hello')],
-		})
-
-		expect(provider.requests.at(-1)?.enforceToolInputSchema).toEqual(['edit'])
-	})
-})