@namzu/sdk 14.0.7 → 15.0.0

package/src/runtime/query/__tests__/content-budget.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { describeDroppedContent, measureContentBytes } from '../tool-output-budget.js'
-
-/**
- * The output budget takes `output: string` only, so the rich channel was
- * never bounded — an image block of any size passed untouched on the turn
- * that produced it, and that is the single largest payload a tool result
- * can carry.
- *
- * Worse than uncontrolled cost: when the TEXT half truncated, the rich
- * half was dropped with it, silently. Dropping is correct — the preview is
- * no longer the tool's own payload, so an image alongside it would be
- * illustrating something the model can no longer read — but the model saw
- * a preview and had no way to know an image had ever existed, so it
- * reasoned as though the tool returned text only.
- */
-
-describe('naming what a truncated result took with it', () => {
-	it('says what kind of block went, and how many', () => {
-		const text = describeDroppedContent([
-			{ type: 'text', text: 'summary' },
-			{ type: 'image', data: 'aGk=' },
-			{ type: 'image', data: 'aGk=' },
-		])
-
-		expect(text).toContain('2 image blocks')
-		// A fact the agent can act on — ask for a smaller region, re-run
-		// against a file — where silence looks like a text-only tool.
-		expect(text).toContain('omitted')
-	})
-
-	it('uses the singular for one block', () => {
-		expect(describeDroppedContent([{ type: 'image', data: 'x' }])).toContain('1 image')
-	})
-
-	it('says nothing when there was only text to lose', () => {
-		// The ordinary case must add no noise.
-		expect(describeDroppedContent([{ type: 'text', text: 'a' }])).toBeUndefined()
-	})
-
-	it('says nothing for a result with no rich channel at all', () => {
-		expect(describeDroppedContent(undefined)).toBeUndefined()
-		expect(describeDroppedContent('just a string')).toBeUndefined()
-	})
-
-	it('names an unfamiliar block kind rather than skipping it', () => {
-		// An unknown block is still something the model cannot see.
-		expect(describeDroppedContent([{ type: 'chart', data: 'x' }])).toContain('chart')
-	})
-
-	it('counts a block with no type at all', () => {
-		expect(describeDroppedContent([{ data: 'x' }])).toContain('content')
-	})
-})
-
-describe('measuring the rich channel', () => {
-	it('measures the payload, not the block count', () => {
-		// One block is the whole cost: a single screenshot is the largest
-		// thing a tool result can carry.
-		expect(measureContentBytes([{ type: 'image', data: 'x'.repeat(500) }])).toBe(500)
-	})
-
-	it('adds every block together', () => {
-		expect(
-			measureContentBytes([
-				{ type: 'text', text: 'ab' },
-				{ type: 'image', data: 'xyz' },
-			]),
-		).toBe(5)
-	})
-
-	it('is zero for a result with no rich channel', () => {
-		expect(measureContentBytes(undefined)).toBe(0)
-		expect(measureContentBytes([])).toBe(0)
-	})
-
-	it('ignores a block whose payload is not a string', () => {
-		// A malformed block contributes no measurable size rather than
-		// throwing inside a budget check.
-		expect(measureContentBytes([{ type: 'image', data: { buffer: [] } }])).toBe(0)
-	})
-})

package/src/runtime/query/__tests__/context-size-on-the-wire.test.ts

@@ -1,122 +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 { createUserMessage } from '../../../types/message/index.js'
-import type { RunEvent } from '../../../types/run/index.js'
-import { drainQuery } from '../index.js'
-
-/**
- * Cumulative spend and current context size are different quantities, and a
- * host divided the first by a context window and shipped it.
- *
- * That indicator climbed toward full on any long run no matter how much room
- * the conversation actually had — most wrong exactly when someone needed it —
- * because `usage` is summed over every turn and never falls, while the context
- * is what is being sent right now and falls whenever a compaction sheds.
- *
- * The host had no better option: the correct numerator needs internals it
- * cannot see, and the correct denominator was a two-branch guess on a model
- * name. So both numbers are on the event, named so that reaching for the wrong
- * one is a visible mistake rather than a plausible guess.
- */
-
-let workdirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-type UsageEvent = Extract<RunEvent, { type: 'token_usage_updated' }>
-
-async function run(
-	compaction: Record<string, unknown> | undefined,
-	turns: unknown[],
-): Promise<UsageEvent[]> {
-	const seen: UsageEvent[] = []
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-ctxsize-'))
-	workdirs.push(dir)
-
-	await drainQuery(
-		{
-			provider: new MockLLMProvider({ turns: turns as never }),
-			tools: new ToolRegistry(),
-			runConfig: { model: 'mock-model', timeoutMs: 30_000, tokenBudget: 100_000, maxIterations: 3 },
-			...(compaction ? { compactionConfig: compaction } : {}),
-			agentId: 'agent_ctx',
-			agentName: 'Context Agent',
-			workingDirectory: dir,
-			sessionId: 'ses_ctx',
-			threadId: 'thd_ctx',
-			projectId: 'prj_ctx',
-			tenantId: 'tnt_ctx',
-			messages: [createUserMessage('go')],
-		} as never,
-		(event: RunEvent) => {
-			if (event.type === 'token_usage_updated') seen.push(event)
-		},
-	)
-
-	return seen
-}
-
-const COMPACTION = {
-	strategy: 'sliding-window',
-	triggerThreshold: 0.9,
-	contextWindowTokens: 50_000,
-	keepRecentMessages: 4,
-}
-
-describe('a run reports how much room its context has', () => {
-	it('carries the context size and the window together', async () => {
-		const events = await run(COMPACTION, [{ text: 'done' }])
-
-		expect(events.length).toBeGreaterThan(0)
-		const event = events[0] as UsageEvent
-		expect(event.contextTokens).toBeGreaterThan(0)
-		expect(event.contextWindowTokens).toBe(50_000)
-	})
-
-	it('says whether each number was measured or guessed', async () => {
-		// A fraction is only as honest as the weaker of its two terms, so a
-		// surface rendering these owes a reader the distinction. It cannot
-		// pass it on if it never receives it.
-		const event = (await run(COMPACTION, [{ text: 'done' }]))[0] as UsageEvent
-
-		expect(['provider', 'estimate']).toContain(event.contextMeasuredBy)
-		// The window was stated in config here, so its provenance is not a guess.
-		expect(event.windowSource).toBe('config')
-	})
-
-	it('keeps the context size distinct from cumulative spend', async () => {
-		// The whole defect in one assertion, and this driver demonstrates it
-		// more sharply than a real one would: it reports no usage at all, so
-		// cumulative spend stays at zero while the context genuinely fills.
-		//
-		// A surface dividing spend by a window would show 0% here, for a
-		// conversation that is really there. The same surface on a long run
-		// shows 100% for a conversation that was compacted down to nothing.
-		// Both directions, same category error — which is why the two numbers
-		// are reported separately rather than left to be inferred from each
-		// other.
-		const events = await run(COMPACTION, [{ text: 'one' }, { text: 'two' }])
-		const last = events[events.length - 1] as UsageEvent
-
-		expect(last.contextTokens).toBeGreaterThan(0)
-		expect(last.contextTokens).not.toBe(last.usage.totalTokens)
-	})
-
-	it('reports nothing rather than a guess when no window is configured', async () => {
-		// Without a compaction config nothing resolves a window, and inventing
-		// one would be the guess this replaces. Absent is a fact a surface can
-		// act on; a fabricated default is not.
-		const event = (await run(undefined, [{ text: 'done' }]))[0] as UsageEvent
-
-		expect(event.contextTokens).toBeUndefined()
-		expect(event.contextWindowTokens).toBeUndefined()
-		expect(event.windowSource).toBeUndefined()
-	})
-})

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

@@ -1,127 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { DefaultPathBuilder, type PathBuilder } from '../../../session/workspace/path-builder.js'
-import { posix } from '../../../test-support/paths.js'
-import type { RunId, SessionId, TenantId } from '../../../types/ids/index.js'
-import type { LLMProvider } from '../../../types/provider/index.js'
-import type { AgentRunConfig } from '../../../types/run/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { RunContextFactory } from '../context.js'
-
-function mockProvider(): LLMProvider {
-	return {
-		id: 'mock',
-		supports: () => true,
-		chat: async () => ({ message: { role: 'assistant', content: '' } }),
-	} as unknown as LLMProvider
-}
-
-function buildConfig(overrides: Partial<Parameters<typeof RunContextFactory.build>[0]> = {}) {
-	const sessionId = 'ses_test' as SessionId
-	const threadId = 'thd_test' as ThreadId
-	const projectId = 'prj_test' as ProjectId
-	const tenantId = 'tnt_test' as TenantId
-	const runConfig: AgentRunConfig = {
-		model: 'test',
-		tokenBudget: 1_000,
-		timeoutMs: 5_000,
-	}
-
-	return {
-		agentId: 'agent-1',
-		agentName: 'agent-1',
-		runConfig,
-		provider: mockProvider(),
-		messages: [],
-		sessionId,
-		threadId,
-		projectId,
-		tenantId,
-		workingDirectory: '/tmp/run-context-test',
-		...overrides,
-	}
-}
-
-describe('RunContextFactory.build', () => {
-	it('requires sessionId, threadId, projectId, tenantId and returns them on the context', () => {
-		const cfg = buildConfig()
-		const ctx = RunContextFactory.build(cfg)
-
-		expect(ctx.sessionId).toBe(cfg.sessionId)
-		expect(ctx.threadId).toBe(cfg.threadId)
-		expect(ctx.projectId).toBe(cfg.projectId)
-		expect(ctx.tenantId).toBe(cfg.tenantId)
-	})
-
-	it('uses the injected PathBuilder to resolve the output dir (no hardcoded .namzu/threads)', () => {
-		const pathBuilderMock: PathBuilder = {
-			rootDir: vi.fn(() => '/mock/root'),
-			projectDir: vi.fn((pid) => `/mock/root/projects/${pid}`),
-			sessionDir: vi.fn((pid, sid) => `/mock/root/projects/${pid}/sessions/${sid}`),
-			subSessionDir: vi.fn(),
-			runDir: vi.fn(),
-		}
-
-		const cfg = buildConfig({ pathBuilder: pathBuilderMock })
-		const ctx = RunContextFactory.build(cfg)
-
-		expect(pathBuilderMock.sessionDir).toHaveBeenCalledWith(cfg.projectId, cfg.sessionId)
-		expect(ctx.outputDir).toBe(`/mock/root/projects/${cfg.projectId}/sessions/${cfg.sessionId}`)
-		// Legacy hardcoded path must not leak.
-		expect(ctx.outputDir).not.toContain('.namzu/threads')
-	})
-
-	it('falls back to DefaultPathBuilder rooted at {cwd}/.namzu when no pathBuilder is provided', () => {
-		const cfg = buildConfig()
-		const ctx = RunContextFactory.build(cfg)
-
-		// Layout lives under projects/{pid}/sessions/{sid} — no `.namzu/threads/`.
-		expect(posix(ctx.outputDir)).toContain('/.namzu/projects/prj_test/sessions/ses_test')
-		expect(ctx.outputDir).not.toContain('threads')
-	})
-
-	it('seeds RunPersistence with propagated sessionId/threadId/tenantId/projectId', () => {
-		const cfg = buildConfig()
-		const ctx = RunContextFactory.build(cfg)
-
-		expect(ctx.runMgr.sessionId).toBe(cfg.sessionId)
-		expect(ctx.runMgr.threadId).toBe(cfg.threadId)
-		expect(ctx.runMgr.tenantId).toBe(cfg.tenantId)
-		expect(ctx.runMgr.projectId).toBe(cfg.projectId)
-	})
-
-	it('reuses the runId supplied by the caller', () => {
-		const runId = 'run_fixed' as RunId
-		const ctx = RunContextFactory.build(buildConfig({ runId }))
-		expect(ctx.runId).toBe(runId)
-	})
-
-	it('DefaultPathBuilder lays out runs under sessions/{sessionId}/runs', () => {
-		const builder = new DefaultPathBuilder('/base/.namzu')
-		const runDir = builder.runDir('prj_x' as ProjectId, 'ses_y' as SessionId, 'run_z' as RunId)
-		expect(posix(runDir)).toBe('/base/.namzu/projects/prj_x/sessions/ses_y/runs/run_z')
-	})
-
-	it("carries the caller's stop reason across into the run", () => {
-		// This is the frame that was losing it. The host aborts with a
-		// sentence, the run re-aborts with nothing, and every layer below —
-		// the tool executor, the tool itself, the result the model reads —
-		// can only report that something stopped. The words do not survive
-		// the hop unless this site forwards them.
-		const host = new AbortController()
-		const ctx = RunContextFactory.build(buildConfig({ signal: host.signal }))
-
-		host.abort(new Error('nightly window closed'))
-
-		expect(ctx.abortController.signal.aborted).toBe(true)
-		expect((ctx.abortController.signal.reason as Error)?.message).toBe('nightly window closed')
-	})
-
-	it('still aborts when the caller gave no reason', () => {
-		const host = new AbortController()
-		const ctx = RunContextFactory.build(buildConfig({ signal: host.signal }))
-
-		host.abort()
-
-		expect(ctx.abortController.signal.aborted).toBe(true)
-	})
-})

package/src/runtime/query/__tests__/deferred-tools.test.ts

@@ -1,216 +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 { SearchToolsTool } from '../../../tools/builtins/search-tools.js'
-import type { RunId, 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'
-
-/**
- * The scriptable mock captures every request it receives, which is all
- * this suite ever needed a hand-rolled provider for. Keeping a bespoke
- * class here would mean re-implementing the frame sequence by hand — the
- * exact duplication the mock was rebuilt to remove.
- */
-function capturingProvider(): MockLLMProvider {
-	return new MockLLMProvider({ turns: [{ text: 'done' }] })
-}
-
-function registerDeferredDocumentTool(tools: ToolRegistry, name = 'generate_document'): void {
-	tools.register(
-		{
-			name,
-			description: 'Generate a project document by document id.',
-			inputSchema: z.object({
-				documentId: z.string(),
-			}),
-			execute: async () => ({ success: true, output: 'generated' }),
-		},
-		'deferred',
-	)
-}
-
-describe('query deferred tool discovery', () => {
-	let workdirs: string[] = []
-
-	afterEach(async () => {
-		await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })))
-		workdirs = []
-	})
-
-	it('auto-exposes search_tools when deferred tools are registered', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerDeferredDocumentTool(tools)
-
-		const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-deferred-tools-'))
-		workdirs.push(workingDirectory)
-
-		const run = await drainQuery({
-			provider,
-			tools,
-			runConfig: {
-				model: 'mock-model',
-				timeoutMs: 5_000,
-				tokenBudget: 100_000,
-				maxIterations: 1,
-				maxResponseTokens: 256,
-			},
-			agentId: 'agent_test',
-			agentName: 'Test Agent',
-			messages: [createUserMessage('what tools can you use?')],
-			workingDirectory,
-			sessionId: 'ses_deferred_tools' as SessionId,
-			threadId: 'thd_deferred_tools' as ThreadId,
-			projectId: 'prj_deferred_tools' as ProjectId,
-			tenantId: 'tnt_deferred_tools' as TenantId,
-		})
-
-		expect(run.status).toBe('completed')
-		expect(tools.has(SearchToolsTool.name)).toBe(true)
-		expect(tools.getAvailability(SearchToolsTool.name)).toBe('active')
-		expect(tools.getAvailability('generate_document')).toBe('deferred')
-
-		const toolNames =
-			provider.requests
-				.at(-1)
-				?.tools?.map((tool) => tool.function.name)
-				.sort() ?? []
-		expect(toolNames).toEqual([SearchToolsTool.name])
-
-		const systemPrompt = (provider.requests.at(-1)?.messages ?? [])
-			.filter((message) => message.role === 'system')
-			.map((message) => message.content)
-			.join('\n')
-		expect(systemPrompt).toContain('Use search_tools to load these before use:')
-		expect(systemPrompt).toContain('- generate_document')
-		expect(systemPrompt).not.toContain(
-			'Deferred tools are discoverable but not executable until the runtime activates them',
-		)
-	})
-
-	it('keeps search_tools executable when allowedTools names a deferred tool', async () => {
-		const provider = capturingProvider()
-		const tools = new ToolRegistry()
-		registerDeferredDocumentTool(tools)
-
-		const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-deferred-tools-'))
-		workdirs.push(workingDirectory)
-
-		const run = await drainQuery({
-			provider,
-			tools,
-			allowedTools: ['generate_document'],
-			runConfig: {
-				model: 'mock-model',
-				timeoutMs: 5_000,
-				tokenBudget: 100_000,
-				maxIterations: 1,
-				maxResponseTokens: 256,
-			},
-			agentId: 'agent_test',
-			agentName: 'Test Agent',
-			messages: [createUserMessage('generate D-01')],
-			workingDirectory,
-			sessionId: 'ses_deferred_allowed_tools' as SessionId,
-			threadId: 'thd_deferred_allowed_tools' as ThreadId,
-			projectId: 'prj_deferred_allowed_tools' as ProjectId,
-			tenantId: 'tnt_deferred_allowed_tools' as TenantId,
-		})
-
-		expect(run.status).toBe('completed')
-		expect(tools.getAvailability('generate_document')).toBe('deferred')
-
-		const toolNames =
-			provider.requests
-				.at(-1)
-				?.tools?.map((tool) => tool.function.name)
-				.sort() ?? []
-		expect(toolNames).toEqual([SearchToolsTool.name])
-
-		const systemPrompt = (provider.requests.at(-1)?.messages ?? [])
-			.filter((message) => message.role === 'system')
-			.map((message) => message.content)
-			.join('\n')
-		expect(systemPrompt).toContain('Use search_tools to load these before use:')
-		expect(systemPrompt).toContain('- generate_document')
-	})
-
-	it('does not let search_tools reveal or activate deferred tools outside allowedTools', async () => {
-		const tools = new ToolRegistry()
-		registerDeferredDocumentTool(tools)
-		registerDeferredDocumentTool(tools, 'dangerous_purge_document')
-
-		// 'dangerous' matches only the out-of-allowlist tool ('delete'-style
-		// CRUD verbs are stop tokens and never match anything by themselves).
-		const result = await SearchToolsTool.execute(
-			{ query: 'dangerous' },
-			{
-				runId: 'run_deferred_allowed_tools' as RunId,
-				workingDirectory: '/tmp',
-				abortSignal: new AbortController().signal,
-				env: {},
-				log: () => undefined,
-				toolRegistry: tools,
-				allowedTools: ['generate_document', SearchToolsTool.name],
-			},
-		)
-
-		expect(result.success).toBe(true)
-		expect(result.output).toContain('No deferred tools matching "dangerous"')
-		expect(result.output).not.toContain('dangerous_purge_document')
-		expect(tools.getAvailability('generate_document')).toBe('deferred')
-		expect(tools.getAvailability('dangerous_purge_document')).toBe('deferred')
-	})
-
-	it('activates only the top-5 ranked matches and reports near-misses without activating', async () => {
-		const tools = new ToolRegistry()
-		// Eight deferred tools that all match "invoice" equally by name; the
-		// alphabetical tie-break makes the top-5 cut deterministic.
-		const names = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'].map((s) => `invoice_${s}`)
-		for (const name of names) {
-			tools.register(
-				{
-					name,
-					description: `Billing helper ${name.slice(-1)}.`,
-					inputSchema: z.object({ id: z.string() }),
-					execute: async () => ({ success: true, output: 'ok' }),
-				},
-				'deferred',
-			)
-		}
-
-		const result = await SearchToolsTool.execute(
-			{ query: 'invoice' },
-			{
-				runId: 'run_deferred_top_k' as RunId,
-				workingDirectory: '/tmp',
-				abortSignal: new AbortController().signal,
-				env: {},
-				log: () => undefined,
-				toolRegistry: tools,
-			},
-		)
-
-		expect(result.success).toBe(true)
-		expect(result.output).toContain('Activated 5 tool(s)')
-		expect(result.output).toContain('NOT loaded')
-		expect(result.data).toMatchObject({
-			activated: ['invoice_a', 'invoice_b', 'invoice_c', 'invoice_d', 'invoice_e'],
-			count: 5,
-			nearMisses: ['invoice_f', 'invoice_g', 'invoice_h'],
-		})
-		for (const name of ['invoice_a', 'invoice_b', 'invoice_c', 'invoice_d', 'invoice_e']) {
-			expect(tools.getAvailability(name)).toBe('active')
-		}
-		for (const name of ['invoice_f', 'invoice_g', 'invoice_h']) {
-			expect(tools.getAvailability(name)).toBe('deferred')
-		}
-	})
-})