@namzu/sdk 14.0.7 → 15.0.0

package/src/agents/__tests__/reachability.test.ts

@@ -1,224 +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 { ReactiveAgentConfig } from '../../types/agent/reactive.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 { ToolDefinition } from '../../types/tool/index.js'
-import { ReactiveAgent } from '../ReactiveAgent.js'
-
-/**
- * `ReactiveAgent` is the entry point consumers actually use — it is what
- * `AgentManager` spawns and what the estate's own applications call. It
- * forwarded none of the loop-control seams on `QueryParams`, so a per-tool
- * deadline, a retry policy, a guardrail or a stop condition was reachable
- * only by dropping to `query()` and rebuilding the run wiring by hand.
- *
- * A feature a consumer cannot reach is a feature that does not exist for
- * them, so these assert reachability rather than behavior — the behavior
- * already has its own tests one layer down.
- */
-
-const agent = () =>
-	new ReactiveAgent({
-		id: 'reach',
-		name: 'Reach',
-		version: '1.0.0',
-		category: 'test',
-		description: 'reachability probe',
-	})
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-function fsTool(name: string): ToolDefinition {
-	return {
-		name,
-		description: `${name} tool`,
-		inputSchema: z.object({}),
-		category: 'filesystem',
-		permissions: ['file_read'],
-		execute: () => Promise.resolve({ success: true, output: 'ok' }),
-	} as unknown as ToolDefinition
-}
-
-async function baseConfig(provider: MockLLMProvider, tools: ToolRegistry) {
-	const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-reach-'))
-	dirs.push(workingDirectory)
-	return {
-		workingDirectory,
-		config: {
-			model: 'mock-model',
-			tokenBudget: 100_000,
-			timeoutMs: 10_000,
-			maxIterations: 4,
-			provider,
-			tools,
-			sessionId: 'ses_r' as SessionId,
-			threadId: 'thd_r' as ThreadId,
-			projectId: 'prj_r' as ProjectId,
-			tenantId: 'tnt_r' as TenantId,
-		} satisfies ReactiveAgentConfig,
-	}
-}
-
-describe('ReactiveAgent forwards the loop-control seams', () => {
-	it('reaches an output guardrail', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'raw answer' }] })
-		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
-
-		const result = await agent().run(
-			{ messages: [createUserMessage('go')], workingDirectory },
-			{ ...config, outputGuardrails: [() => ({ action: 'rewrite', output: 'cleaned' })] },
-		)
-
-		expect(result.result).toBe('cleaned')
-	})
-
-	it('reaches a stop condition', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
-		})
-		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
-
-		await agent().run(
-			{ messages: [createUserMessage('go')], workingDirectory },
-			{ ...config, stopWhen: () => true },
-		)
-
-		expect(provider.requests).toHaveLength(1)
-	})
-
-	it('reaches prepareStep', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
-
-		await agent().run(
-			{ messages: [createUserMessage('go')], workingDirectory },
-			{ ...config, prepareStep: () => ({ model: 'swapped-model' }) },
-		)
-
-		expect(provider.requests[0]?.model).toBe('swapped-model')
-	})
-
-	it('reaches an input guardrail, so a refusal costs nothing', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'never' }] })
-		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
-
-		const result = await agent().run(
-			{ messages: [createUserMessage('go')], workingDirectory },
-			{ ...config, inputGuardrails: [() => ({ action: 'block', reason: 'no' })] },
-		)
-
-		expect(provider.requests).toHaveLength(0)
-		expect(result.stopReason).toBe('input_guardrail')
-	})
-
-	it('reaches onStepFinish', async () => {
-		// A step is recorded per TOOL-CALLING turn: a text-only turn breaks
-		// out of the loop before `recordStep` runs, so drive one tool call.
-		// (That the final text turn produces no step is worth revisiting on
-		// its own — it is a real hole in `Run.steps` — but changing loop
-		// semantics is not what this test is for.)
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'read_file', args: {} }] }, { text: 'done' }],
-		})
-		const tools = new ToolRegistry()
-		tools.register(fsTool('read_file'))
-		const { workingDirectory, config } = await baseConfig(provider, tools)
-		const onStepFinish = vi.fn()
-
-		await agent().run(
-			{ messages: [createUserMessage('go')], workingDirectory },
-			{ ...config, onStepFinish },
-		)
-
-		expect(onStepFinish).toHaveBeenCalled()
-	})
-})
-
-describe('the <env> block keys on what a tool declares, not its name', () => {
-	it('emits it for a filesystem tool that is not one of the four built-in names', async () => {
-		// A host registering `read_file` with `category: 'filesystem'` and
-		// `permissions: ['file_read']` used to get NO env block, so the model
-		// was never told its working directory and the host hand-encoded
-		// paths into the system prompt instead.
-		const tools = new ToolRegistry()
-		tools.register(fsTool('read_file'))
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const { workingDirectory, config } = await baseConfig(provider, tools)
-
-		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
-
-		const system = (provider.requests[0]?.messages ?? [])
-			.filter((m) => m.role === 'system')
-			.map((m) => m.content)
-			.join('\n')
-		expect(system).toContain(workingDirectory)
-	})
-
-	it('still says nothing when no tool touches the filesystem', async () => {
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'add',
-			description: 'add numbers',
-			inputSchema: z.object({}),
-			category: 'analysis',
-			execute: () => Promise.resolve({ success: true, output: '2' }),
-		} as unknown as ToolDefinition)
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
-		const { workingDirectory, config } = await baseConfig(provider, tools)
-
-		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
-
-		const system = (provider.requests[0]?.messages ?? [])
-			.filter((m) => m.role === 'system')
-			.map((m) => m.content)
-			.join('\n')
-		expect(system).not.toContain(workingDirectory)
-	})
-})
-
-describe('a provider is not handed the live run array', () => {
-	it('what a driver retained at turn 1 still reads as turn 1 afterwards', async () => {
-		// `runMgr.messages` is the live array and the loop pushes onto it
-		// after the call returns, so a driver that retained its input watched
-		// it grow new turns underneath. A capture provider in the estate
-		// recorded every turn as identical to the last for exactly this.
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'read_file', args: {} }] }, { text: 'done' }],
-		})
-		// Retain the REFERENCE, exactly as a logging or caching driver would,
-		// and read it only after the whole run has finished. Reading it
-		// during the call proves nothing — the divergence appears later.
-		const retained: (readonly unknown[])[] = []
-		const original = provider.chatStream.bind(provider)
-		provider.chatStream = (params) => {
-			retained.push(params.messages)
-			return original(params)
-		}
-
-		const tools = new ToolRegistry()
-		tools.register(fsTool('read_file'))
-		const { workingDirectory, config } = await baseConfig(provider, tools)
-
-		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
-
-		expect(retained.length).toBeGreaterThanOrEqual(2)
-		// Two distinct arrays, not one aliased one.
-		expect(retained[0]).not.toBe(retained[1])
-		// And turn 1's copy still describes turn 1. With the live array both
-		// entries had grown to the final length by now.
-		expect(retained[0]?.length).toBeLessThan(retained[1]?.length as number)
-	})
-})

package/src/agents/__tests__/run-agent-forwarding.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import { MockLLMProvider, registerMock } from '../../provider/index.js'
-import { ToolRegistry } from '../../registry/index.js'
-import { runAgent } from '../runAgent.js'
-
-/**
- * The `drainQuery` call in `runAgent` was written `as never`.
- *
- * That cast was not load-bearing — removing it typechecks clean — but while it
- * was there the kernel seam was unchecked in both directions: a field the
- * kernel accepts and this door forgot to forward produced no error, and neither
- * did a field spelled wrong. Two were already missing when it was removed.
- *
- * `skills` is the one with a caller in this repo. `@namzu/project` reads a
- * whole `skills/` directory, put them on the options, and every one was dropped
- * on the floor — the run was assembled without them and said nothing. These
- * pin the forwarding rather than the cast, because the cast can come back and
- * a test that only asserted its absence would not notice.
- */
-
-registerMock()
-
-describe('runAgent forwards what the kernel takes', () => {
-	it('puts skills in front of the model', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'ok' }] })
-
-		await runAgent({
-			provider,
-			model: 'mock-model',
-			prompt: 'plan something',
-			skills: [
-				{
-					metadata: { name: 'plan-a-trip', description: 'Plan a trip end to end' },
-					body: 'Ask for dates first.',
-					dirPath: '/tmp/skills/plan-a-trip',
-				},
-			],
-		})
-
-		// Serialized rather than reached into: the prompt builder decides where a
-		// skill lands, and pinning that path here would make this test fail on a
-		// refactor that kept the behaviour. What matters is that it arrived.
-		expect(JSON.stringify(provider.requests[0])).toContain('plan-a-trip')
-	})
-
-	it('forwards the verification gate, so a denied tool does not run', async () => {
-		// The first version of this test asserted `run.status === 'completed'`
-		// with the gate set. It passed with the forwarding deleted — a run with
-		// no gate completes too — so it proved nothing. A gate is only observable
-		// through a call it stops, which means the assertion has to be about
-		// whether the tool body ran.
-		let ran = false
-
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'delete_everything',
-			description: 'Deletes everything.',
-			inputSchema: z.object({}),
-			execute: async () => {
-				ran = true
-				return { success: true, output: 'deleted' }
-			},
-		})
-
-		await runAgent({
-			provider: new MockLLMProvider({
-				turns: [{ toolCalls: [{ name: 'delete_everything', args: {} }] }, { text: 'done' }],
-			}),
-			model: 'mock-model',
-			prompt: 'clean up',
-			tools,
-			verificationGate: {
-				enabled: true,
-				rules: [{ type: 'deny_by_name', toolNames: ['delete_everything'] }],
-				allowReadOnlyTools: false,
-				denyDangerousPatterns: false,
-				logDecisions: false,
-			},
-		})
-
-		expect(ran).toBe(false)
-	})
-})

package/src/agents/__tests__/run-agent.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import { MockLLMProvider, registerMock } from '../../provider/index.js'
-import { ToolRegistry } from '../../registry/index.js'
-import { runAgent } from '../runAgent.js'
-
-/**
- * `drainQuery` takes eleven required parameters, four of which throw when
- * missing. That is right for a kernel and wrong for the first thing anybody
- * writes — and the proof was in this repo, where the eval suites, the test
- * files and the CLI each hand-assembled the same block.
- *
- * These pin the two things a front door has to get right: that the short form
- * works at all, and that the identity it invents comes back, because a
- * generated session that a caller cannot recover is a conversation that
- * silently restarts on turn two.
- */
-
-registerMock()
-
-describe('running an agent through the front door', () => {
-	it('runs from a provider, a model and a prompt', async () => {
-		const { output, run } = await runAgent({
-			provider: new MockLLMProvider({ turns: [{ text: 'four' }] }),
-			model: 'mock-model',
-			prompt: 'What is 2 + 2?',
-		})
-
-		expect(output).toBe('four')
-		expect(run.status).toBe('completed')
-		expect(run.stopReason).toBe('end_turn')
-	})
-
-	it('hands back the identity it generated, so a second turn can continue', async () => {
-		const first = await runAgent({
-			provider: new MockLLMProvider({ turns: [{ text: 'noted' }] }),
-			model: 'mock-model',
-			prompt: 'My name is Ada.',
-		})
-
-		expect(first.identity.sessionId).toBeTruthy()
-		expect(first.identity.tenantId).toBeTruthy()
-
-		const second = await runAgent({
-			provider: new MockLLMProvider({ turns: [{ text: 'Ada' }] }),
-			model: 'mock-model',
-			prompt: 'What is my name?',
-			...first.identity,
-		})
-
-		// The same session, not a new one that happens to work.
-		expect(second.identity).toEqual(first.identity)
-	})
-
-	it('generates a distinct identity per run when none is given', async () => {
-		const a = await runAgent({
-			provider: new MockLLMProvider({ turns: [{ text: 'a' }] }),
-			model: 'mock-model',
-			prompt: 'x',
-		})
-		const b = await runAgent({
-			provider: new MockLLMProvider({ turns: [{ text: 'b' }] }),
-			model: 'mock-model',
-			prompt: 'y',
-		})
-
-		expect(a.identity.sessionId).not.toBe(b.identity.sessionId)
-	})
-
-	it('carries prior messages when the prompt is a history', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'Ada' }] })
-
-		await runAgent({
-			provider,
-			model: 'mock-model',
-			prompt: [
-				{ role: 'user', content: 'My name is Ada.' },
-				{ role: 'assistant', content: 'Noted.' },
-				{ role: 'user', content: 'What is my name?' },
-			] as never,
-		})
-
-		const sent = provider.requests[0]?.messages.map((m) => m.content) ?? []
-		expect(sent).toContain('My name is Ada.')
-		expect(sent).toContain('What is my name?')
-	})
-
-	it('passes instructions through as the system prompt', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'ok' }] })
-
-		await runAgent({
-			provider,
-			model: 'mock-model',
-			prompt: 'hello',
-			instructions: 'You only answer in haiku.',
-		})
-
-		const system = JSON.stringify(provider.requests[0]?.messages ?? [])
-		expect(system).toContain('You only answer in haiku.')
-	})
-
-	it('runs tools when given a registry', async () => {
-		const tools = new ToolRegistry()
-		let ran = false
-		tools.register({
-			name: 'ping',
-			description: 'pings',
-			inputSchema: z.object({}),
-			category: 'custom',
-			permissions: [],
-			readOnly: true,
-			destructive: false,
-			concurrencySafe: true,
-			execute: async () => {
-				ran = true
-				return { success: true, output: 'pong' }
-			},
-		} as never)
-
-		const { output } = await runAgent({
-			provider: new MockLLMProvider({
-				turns: [{ toolCalls: [{ id: 'c1', name: 'ping', rawArguments: '{}' }] }, { text: 'done' }],
-			}),
-			model: 'mock-model',
-			prompt: 'ping it',
-			tools,
-		})
-
-		expect(ran).toBe(true)
-		expect(output).toBe('done')
-	})
-
-	it('caps a runaway loop on its own default', async () => {
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'again',
-			description: 'always asks for more',
-			inputSchema: z.object({}),
-			category: 'custom',
-			permissions: [],
-			readOnly: true,
-			destructive: false,
-			concurrencySafe: true,
-			execute: async () => ({ success: true, output: 'and again' }),
-		} as never)
-
-		// The point of a default budget is that a caller who set none is still
-		// protected. Two iterations here rather than the default sixteen, so
-		// the test pins the mechanism without paying for it.
-		const { run } = await runAgent({
-			provider: new MockLLMProvider({
-				turns: Array.from({ length: 10 }, () => ({
-					toolCalls: [{ id: 'c', name: 'again', rawArguments: '{}' }],
-				})),
-			}),
-			model: 'mock-model',
-			prompt: 'loop',
-			tools,
-			maxIterations: 2,
-		})
-
-		expect(run.currentIteration).toBeLessThanOrEqual(2)
-	})
-})

package/src/agents/__tests__/run-completed-stop-reason.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { MockLLMProvider, registerMock } from '../../provider/index.js'
-import type { RunEvent } from '../../types/run/index.js'
-import { runAgent } from '../runAgent.js'
-
-/**
- * `completed` is not `succeeded`.
- *
- * `run_failed` is emitted from exactly one place — the throw path in
- * `result.ts` — so every other way a run can end badly arrives as
- * `run_completed`: the token budget, the timeout, the iteration cap, a
- * cancellation, and a blocking output guardrail. A consumer reading that event
- * as success reported one for a run whose answer was refused, and the CLI did:
- * it mapped `run_completed` to a bare `done` and exited 0.
- *
- * Measured before the fix: a `max_iterations` stop reports
- * `status: 'completed'`, and the event carried nothing to distinguish it.
- */
-
-registerMock()
-
-async function eventsOf(options: Parameters<typeof runAgent>[0]): Promise<RunEvent[]> {
-	const events: RunEvent[] = []
-	await runAgent({ ...options, listener: (e) => void events.push(e) })
-	return events
-}
-
-function completion(events: RunEvent[]): Extract<RunEvent, { type: 'run_completed' }> | undefined {
-	return events.find((e) => e.type === 'run_completed') as never
-}
-
-describe('run_completed says why the run stopped', () => {
-	it('reports end_turn when the model finished its answer', async () => {
-		const events = await eventsOf({
-			provider: new MockLLMProvider({ turns: [{ text: 'done' }] }),
-			model: 'mock-model',
-			prompt: 'x',
-		})
-
-		expect(completion(events)?.stopReason).toBe('end_turn')
-	})
-
-	it('reports max_iterations when the loop was cut short', async () => {
-		const events = await eventsOf({
-			provider: new MockLLMProvider({ turns: [{ toolCalls: [{ name: 'absent', args: {} }] }] }),
-			model: 'mock-model',
-			prompt: 'x',
-			maxIterations: 1,
-		})
-
-		const done = completion(events)
-		// The event that a consumer treats as "the run ended" — and the field
-		// that stops it being read as "the run succeeded".
-		expect(done).toBeDefined()
-		expect(done?.stopReason).toBe('max_iterations')
-		expect(events.some((e) => e.type === 'run_failed')).toBe(false)
-	})
-})