@namzu/sdk 14.0.7 → 15.1.0

package/src/registry/toolset/catalog.test.ts

@@ -1,282 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import type { ToolDefinition } from '../../types/tool/index.js'
-import { ToolRegistry } from '../tool/execute.js'
-import { ToolCatalog, createToolCatalogFromRegistry } from './catalog.js'
-
-function makeTool(name: string, description = `${name} tool`): ToolDefinition {
-	return {
-		name,
-		description,
-		inputSchema: z.object({ query: z.string().optional() }),
-		async execute() {
-			return { success: true, output: `${name}-ran` }
-		},
-	}
-}
-
-function makeCatalog(): ToolCatalog {
-	const catalog = new ToolCatalog()
-	catalog.registerSource({ id: 'host', kind: 'host_tool', name: 'Host' })
-	catalog.registerToolset({
-		id: 'tools',
-		sourceId: 'host',
-		name: 'Tools',
-		defaultPolicy: { enabled: true, loading: 'eager' },
-	})
-	return catalog
-}
-
-describe('ToolCatalog', () => {
-	it('keeps sources, toolsets, and tools as separate records', () => {
-		const catalog = new ToolCatalog()
-		catalog.registerSource({
-			id: 'mcp:microsoft-learn',
-			kind: 'mcp_server',
-			name: 'Microsoft Learn',
-			mcpServer: {
-				name: 'microsoft-learn',
-				url: 'https://learn.microsoft.com/api/mcp',
-				transport: 'streamable_http',
-			},
-		})
-		catalog.registerToolset({
-			id: 'mcp-toolset:microsoft-learn',
-			sourceId: 'mcp:microsoft-learn',
-			name: 'Microsoft Learn toolset',
-			defaultPolicy: {
-				enabled: true,
-				loading: 'deferred',
-				preferred: true,
-			},
-		})
-		catalog.registerTool({
-			name: 'microsoft_docs_search',
-			description: 'Search Microsoft documentation',
-			sourceId: 'mcp:microsoft-learn',
-			toolsetId: 'mcp-toolset:microsoft-learn',
-			policy: { enabled: true, loading: 'deferred', preferred: true },
-		})
-
-		expect(catalog.listSources()).toHaveLength(1)
-		expect(catalog.listToolsets()).toHaveLength(1)
-		expect(catalog.getToolsByLoading(['deferred']).map((t) => t.name)).toEqual([
-			'microsoft_docs_search',
-		])
-	})
-
-	it('searches deferred tools by name, description, source, and toolset', () => {
-		const registry = new ToolRegistry()
-		registry.register(makeTool('github_search_issues', 'Search repository issues'), 'deferred')
-		registry.register(makeTool('slack_search_messages', 'Search team messages'), 'deferred')
-		registry.register(makeTool('bash', 'Run a shell command'))
-
-		const catalog = createToolCatalogFromRegistry(registry, {
-			source: {
-				id: 'host',
-				kind: 'host_tool',
-				name: 'Host runtime',
-				description: 'Local shell and collaboration tools',
-			},
-			toolset: {
-				id: 'default-host',
-				name: 'Default host tools',
-				defaultPolicy: { enabled: true, loading: 'eager' },
-			},
-		})
-
-		expect(
-			catalog.searchTools('repository', { loading: ['deferred'] }).map((r) => r.tool.name),
-		).toEqual(['github_search_issues'])
-		expect(catalog.toLLMTools().map((t) => t.function.name)).toEqual(['bash'])
-	})
-
-	it('scores and reports the matched facets: partial name, source text, toolset text', () => {
-		const catalog = new ToolCatalog()
-		catalog.registerSource({
-			id: 'host',
-			kind: 'host_tool',
-			name: 'GitHub',
-			description: 'repository automation',
-		})
-		catalog.registerToolset({
-			id: 'issues',
-			sourceId: 'host',
-			name: 'Issue toolset',
-			defaultPolicy: { enabled: true, loading: 'eager' },
-		})
-		catalog.registerTool({
-			name: 'create_issue',
-			description: 'open a ticket',
-			sourceId: 'host',
-			toolsetId: 'issues',
-			policy: { enabled: true, loading: 'eager' },
-		})
-
-		// 'issue' hits the tool NAME (create_issue, partial) AND the TOOLSET name.
-		const byIssue = catalog.searchTools('issue')
-		expect(byIssue).toHaveLength(1)
-		expect([...(byIssue[0]?.matched ?? [])].sort()).toEqual(['name', 'toolset'])
-
-		// 'github' hits only the SOURCE text.
-		const bySource = catalog.searchTools('github')
-		expect(bySource[0]?.matched).toEqual(['source'])
-
-		// An exact name match outscores a partial one.
-		const exact = catalog.searchTools('create_issue')
-		expect(exact[0]?.matched).toContain('name')
-		expect(exact[0]?.score ?? 0).toBeGreaterThan(byIssue[0]?.score ?? 0)
-	})
-
-	it('adds the preferred boost so a preferred tool outranks an equal match', () => {
-		const catalog = new ToolCatalog()
-		catalog.registerSource({ id: 'host', kind: 'host_tool', name: 'Host' })
-		catalog.registerToolset({
-			id: 'ts',
-			sourceId: 'host',
-			name: 'Tools',
-			defaultPolicy: { enabled: true, loading: 'eager' },
-		})
-		catalog.registerTool({
-			name: 'search_plain',
-			description: 'search things',
-			sourceId: 'host',
-			toolsetId: 'ts',
-			policy: { enabled: true, loading: 'eager' },
-		})
-		catalog.registerTool({
-			name: 'search_pref',
-			description: 'search things',
-			sourceId: 'host',
-			toolsetId: 'ts',
-			policy: { enabled: true, loading: 'eager', preferred: true },
-		})
-
-		const results = catalog.searchTools('search')
-		expect(results.map((r) => r.tool.name)).toEqual(['search_pref', 'search_plain'])
-		const pref = results.find((r) => r.tool.name === 'search_pref')?.score ?? 0
-		const plain = results.find((r) => r.tool.name === 'search_plain')?.score ?? 0
-		expect(pref - plain).toBe(1)
-	})
-
-	it('preserves registry availability as catalog loading policy', () => {
-		const registry = new ToolRegistry()
-		registry.register(makeTool('read_file'))
-		registry.register(makeTool('web_search'), 'deferred')
-		registry.register(makeTool('write_file'), 'suspended')
-
-		const catalog = createToolCatalogFromRegistry(registry)
-
-		expect(catalog.getTool('read_file')?.policy.loading).toBe('eager')
-		expect(catalog.getTool('web_search')?.policy.loading).toBe('deferred')
-		expect(catalog.getTool('write_file')?.policy.loading).toBe('suspended')
-		expect(catalog.toLLMTools({ loading: ['suspended'] })).toEqual([])
-	})
-
-	it('rejects catalog, definition, and LLM schema name mismatches', () => {
-		const catalog = makeCatalog()
-		expect(() =>
-			catalog.registerTool({
-				name: 'edit',
-				description: 'Edit a file',
-				sourceId: 'host',
-				toolsetId: 'tools',
-				policy: { enabled: true, loading: 'eager' },
-				definition: makeTool('write'),
-			}),
-		).toThrow(/definition name mismatch/)
-
-		expect(() =>
-			catalog.registerTool({
-				name: 'edit',
-				description: 'Edit a file',
-				sourceId: 'host',
-				toolsetId: 'tools',
-				policy: { enabled: true, loading: 'eager' },
-				llmSchema: {
-					type: 'function',
-					function: {
-						name: 'write',
-						description: 'Write',
-						parameters: { type: 'object' },
-					},
-				},
-			}),
-		).toThrow(/LLM schema name mismatch/)
-	})
-
-	it('rejects an explicit LLM schema that could replace an enforced definition schema', () => {
-		const catalog = makeCatalog()
-		const definition: ToolDefinition = {
-			...makeTool('edit'),
-			modelInputSchema: {
-				type: 'object',
-				properties: { path: { type: 'string' } },
-				required: ['path'],
-				additionalProperties: false,
-			},
-			enforceModelInput: true,
-		}
-
-		expect(() =>
-			catalog.registerTool({
-				name: 'edit',
-				description: 'Edit a file',
-				sourceId: 'host',
-				toolsetId: 'tools',
-				policy: { enabled: true, loading: 'eager' },
-				definition,
-				llmSchema: {
-					type: 'function',
-					function: {
-						name: 'edit',
-						description: 'Unsafe override',
-						parameters: { type: 'object' },
-					},
-				},
-			}),
-		).toThrow(/cannot combine an explicit llmSchema with enforceModelInput/)
-	})
-
-	it('rejects an enforced catalog definition without an explicit model schema', () => {
-		const catalog = makeCatalog()
-		expect(() =>
-			catalog.registerTool({
-				name: 'edit',
-				description: 'Edit a file',
-				sourceId: 'host',
-				toolsetId: 'tools',
-				policy: { enabled: true, loading: 'eager' },
-				definition: {
-					...makeTool('edit'),
-					enforceModelInput: true,
-				},
-			}),
-		).toThrow(/enforceModelInput.*modelInputSchema/)
-	})
-
-	it('uses a definition model schema when no explicit catalog schema overrides it', () => {
-		const registry = new ToolRegistry()
-		const modelInputSchema = {
-			type: 'object',
-			properties: { new_string: { type: 'string' } },
-			required: ['new_string'],
-			additionalProperties: false,
-		}
-		registry.register({
-			...makeTool('edit'),
-			modelInputSchema,
-		})
-
-		const catalog = createToolCatalogFromRegistry(registry)
-		const firstSchema = catalog.toLLMTools()[0]?.function.parameters
-		expect(firstSchema).toEqual(modelInputSchema)
-		expect(firstSchema).not.toBe(modelInputSchema)
-		;(firstSchema?.properties as Record<string, unknown>).newStr = { type: 'string' }
-
-		const nextSchema = catalog.toLLMTools()[0]?.function.parameters
-		expect(nextSchema).toEqual(modelInputSchema)
-		expect(JSON.stringify(nextSchema)).not.toContain('newStr')
-	})
-})

package/src/run/LimitChecker.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { RuntimeConfigSchema } from '../config/runtime.js'
-import { RunConfigSchema } from '../contracts/schemas.js'
-import { checkLimitsDetailed } from './LimitChecker.js'
-
-describe('token budget limits', () => {
-	it('treats tokenBudget 0 as unlimited at runtime', () => {
-		const result = checkLimitsDetailed(
-			{
-				tokenBudget: 0,
-				timeoutMs: 60_000,
-				maxIterations: 10,
-				budgetWarningThreshold: 0.9,
-			},
-			{
-				aborted: false,
-				totalTokens: 10_000_000,
-				totalCost: 0,
-				currentIteration: 1,
-				startTime: Date.now(),
-			},
-		)
-
-		expect(result).toEqual({ type: 'ok' })
-	})
-
-	it('accepts tokenBudget 0 in public runtime config schemas', () => {
-		expect(RuntimeConfigSchema.parse({ tokenBudget: 0 }).tokenBudget).toBe(0)
-		expect(RunConfigSchema.parse({ tokenBudget: 0 }).tokenBudget).toBe(0)
-	})
-})

package/src/runtime/bidi/__tests__/session.test.ts

@@ -1,232 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import { ToolRegistry } from '../../../registry/index.js'
-import { defineTool } from '../../../tools/defineTool.js'
-import type { BidiRunEvent } from '../../../types/bidi/index.js'
-import { createMockBidiProvider } from '../mock.js'
-import { startBidiRun } from '../session.js'
-
-/**
- * Every other seam in this kernel is turn-based by construction: a run
- * has iterations, an iteration sends a complete message list and reads a
- * stream back, and a checkpoint is taken between two of them. A duplex
- * session has none of those boundaries — input keeps arriving while
- * output is still being produced — so the two properties that matter
- * here do not exist in the turn-based path at all: a tool must not stall
- * the stream, and an interruption must invalidate work in flight.
- */
-
-function slowTool(name: string, gate: Promise<void>) {
-	return defineTool({
-		name,
-		description: `${name} tool`,
-		inputSchema: z.object({}),
-		category: 'custom',
-		permissions: [],
-		readOnly: true,
-		destructive: false,
-		concurrencySafe: true,
-		execute: async () => {
-			await gate
-			return { success: true, output: `${name} finished` }
-		},
-	})
-}
-
-function open(gate?: Promise<void>) {
-	const tools = new ToolRegistry()
-	tools.register(slowTool('lookup', gate ?? Promise.resolve()))
-	const provider = createMockBidiProvider()
-	return { tools, provider }
-}
-
-const collect = async (run: { events(): AsyncIterable<BidiRunEvent> }, until: number) => {
-	const seen: BidiRunEvent[] = []
-	for await (const event of run.events()) {
-		seen.push(event)
-		if (seen.length >= until) break
-	}
-	return seen
-}
-
-describe('a session with no turn boundary', () => {
-	it('carries the model text through', async () => {
-		const { tools, provider } = open()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'text', text: 'hello there' })
-		const seen = await collect(run, 1)
-
-		expect(seen[0]).toMatchObject({ type: 'text', text: 'hello there' })
-		await run.close()
-	})
-
-	it('answers a tool call on the same session', async () => {
-		const { tools, provider } = open()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'tool_call', id: 't1', name: 'lookup', arguments: '{}' })
-		const seen = await collect(run, 2)
-
-		expect(seen.map((e) => e.type)).toEqual(['tool_started', 'tool_completed'])
-		expect(provider.session()?.sent).toContainEqual({
-			toolResult: 't1',
-			output: 'lookup finished',
-			isError: false,
-		})
-		await run.close()
-	})
-
-	it('keeps delivering model output while a tool is still running', async () => {
-		// The property the turn-based loop never needs: awaiting a tool
-		// inline would stall the very stream an interruption arrives on.
-		let release: (() => void) | undefined
-		const gate = new Promise<void>((resolve) => {
-			release = resolve
-		})
-		const { tools, provider } = open(gate)
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'tool_call', id: 't1', name: 'lookup', arguments: '{}' })
-		provider.session()?.push({ type: 'text', text: 'still talking' })
-
-		const seen = await collect(run, 2)
-		expect(seen.map((e) => e.type)).toEqual(['tool_started', 'text'])
-
-		release?.()
-		await run.close()
-	})
-
-	it('abandons a tool answer when the human speaks over the model', async () => {
-		// Delivering it would put a stale answer into a conversation that
-		// has moved on.
-		let release: (() => void) | undefined
-		const gate = new Promise<void>((resolve) => {
-			release = resolve
-		})
-		const { tools, provider } = open(gate)
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'tool_call', id: 't1', name: 'lookup', arguments: '{}' })
-		provider.session()?.push({ type: 'interrupted' })
-		release?.()
-
-		const seen = await collect(run, 3)
-		expect(seen.map((e) => e.type)).toEqual(['tool_started', 'interrupted', 'tool_abandoned'])
-		// Nothing was sent back for it.
-		expect(provider.session()?.sent).toEqual([])
-		await run.close()
-	})
-
-	it('answers a tool that finished before the interruption', async () => {
-		const { tools, provider } = open()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'tool_call', id: 't1', name: 'lookup', arguments: '{}' })
-		const seen = await collect(run, 2)
-		provider.session()?.push({ type: 'interrupted' })
-
-		expect(seen.map((e) => e.type)).toEqual(['tool_started', 'tool_completed'])
-		expect(provider.session()?.sent).toHaveLength(1)
-		await run.close()
-	})
-
-	it('reports a tool failure rather than dropping it', async () => {
-		const tools = new ToolRegistry()
-		tools.register(
-			defineTool({
-				name: 'lookup',
-				description: 'lookup',
-				inputSchema: z.object({}),
-				category: 'custom',
-				permissions: [],
-				readOnly: true,
-				destructive: false,
-				concurrencySafe: true,
-				execute: async () => ({ success: false, output: '', error: 'the lookup failed' }),
-			}),
-		)
-		const provider = createMockBidiProvider()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'tool_call', id: 't1', name: 'lookup', arguments: '{}' })
-		const seen = await collect(run, 2)
-
-		expect(seen[1]).toMatchObject({ type: 'tool_completed', isError: true })
-		expect(provider.session()?.sent).toContainEqual({
-			toolResult: 't1',
-			output: 'the lookup failed',
-			isError: true,
-		})
-		await run.close()
-	})
-
-	it('stops reading a driver that keeps talking after it hung up', async () => {
-		// A driver that says it closed and then carries on is misbehaving,
-		// and a loop that kept forwarding would hand a consumer output from
-		// a session it was told had ended.
-		const { tools, provider } = open()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'closed' })
-		provider.session()?.push({ type: 'text', text: 'still here' })
-
-		const seen: BidiRunEvent[] = []
-		for await (const event of run.events()) seen.push(event)
-
-		expect(seen.map((e) => e.type)).toEqual(['closed'])
-	})
-
-	it('ends the event stream when the far side closes', async () => {
-		const { tools, provider } = open()
-		const run = await startBidiRun({
-			provider,
-			tools,
-			connect: { model: 'mock' },
-			workingDirectory: process.cwd(),
-		})
-
-		provider.session()?.push({ type: 'closed', reason: 'the far side hung up' })
-
-		const seen: BidiRunEvent[] = []
-		for await (const event of run.events()) seen.push(event)
-
-		expect(seen).toEqual([{ type: 'closed', runId: run.runId, reason: 'the far side hung up' }])
-	})
-})

package/src/runtime/decision/parser.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { getRootLogger } from '../../utils/logger.js'
-import { DecisionParser } from './parser.js'
-
-function makeParser(): DecisionParser {
-	return new DecisionParser(
-		{
-			validAgentIds: ['agent-a'],
-			minConfidence: 0,
-			maxRetries: 1,
-			fallbackAgentId: 'agent-a',
-		},
-		getRootLogger(),
-	)
-}
-
-describe('DecisionParser', () => {
-	it('extracts JSON from a fenced code block', () => {
-		const parser = makeParser()
-		const raw = '```json\n{"agentId":"agent-a","confidence":0.9}\n```'
-
-		const result = parser.parse(raw)
-
-		expect(result.ok).toBe(true)
-	})
-
-	// `codeBlockMatch` used `\s*\n?` on both sides of a lazy `[\s\S]*?`
-	// capture — whitespace and the capture overlap, so an unterminated
-	// fence forces the engine to explore every way of splitting the same
-	// run of blank lines between them. The trailing non-whitespace `x`
-	// keeps `.trim()` from stripping the blank-line run before the regex
-	// ever runs. A ~1KB unterminated fence (well within a single routing
-	// completion) used to take multiple seconds; this pins it to
-	// comfortably sub-second.
-	it('does not exhibit super-linear backtracking on an unterminated fence with many blank lines', () => {
-		const parser = makeParser()
-		const raw = `\`\`\`json${'\n'.repeat(1000)}x`
-
-		const start = Date.now()
-		const result = parser.parse(raw)
-		const elapsed = Date.now() - start
-
-		expect(elapsed).toBeLessThan(500)
-		expect(result.ok).toBe(false)
-	})
-})

package/src/runtime/query/__tests__/a-plan-that-succeeded-says-so.test.ts

@@ -1,109 +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 {
-	generateProjectId,
-	generateSessionId,
-	generateTenantId,
-	generateThreadId,
-} from '../../../utils/id.js'
-import { drainQuery } from '../index.js'
-
-/**
- * Nothing settled a plan that SUCCEEDED.
- *
- * The error path calls `failPlan`, so a run that blew up said so. The success
- * path never touched the plan manager at all — so a plan could reach `failed`
- * or sit at `executing` forever, but never `completed`. A host reading
- * `plan.status` after a successful run was told the work was still going.
- *
- * Settlement is conditional on every step having reported, and the condition is
- * read rather than caught: `completePlan` refuses an unreported step on
- * purpose, and letting that throw here would turn a run that worked into a run
- * that crashed on its way out — a worse version of the bug the refusal exists
- * to prevent.
- */
-
-registerMock()
-
-/** Run to completion, with a plan seeded through the host's own seam. */
-async function runWithPlan(seed: (pm: PlanManager) => void): Promise<PlanManager> {
-	let captured: PlanManager | undefined
-
-	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(),
-		// The documented host seam: `drainQuery` hands the plan manager over
-		// BEFORE the iteration loop, which is exactly what makes a host-driven
-		// plan possible at all.
-		onContextCreated: ({ planManager }: { planManager: PlanManager }) => {
-			captured = planManager
-			seed(planManager)
-		},
-	} as never)
-
-	if (!captured) throw new Error('onContextCreated never fired')
-	return captured
-}
-
-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()
-}
-
-describe('a run that succeeded settles the plan it was executing', () => {
-	it('reports completed when every step reported', async () => {
-		const pm = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-			p.updateStepStatus('step_2', 'skipped')
-		})
-
-		expect(pm.active?.status).toBe('completed')
-	})
-
-	it('reports failed when a step actually failed', async () => {
-		const pm = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-			p.updateStepStatus('step_2', 'failed')
-		})
-
-		expect(pm.active?.status).toBe('failed')
-	})
-
-	it('leaves it executing — and does not throw — when a step never reported', async () => {
-		// The honest answer. The caller and the plan disagree about whether the
-		// work is over, and the end of a successful run is not the place to
-		// resolve that by guessing. The run itself must still finish cleanly,
-		// which is the half that would break if the refusal were caught here
-		// instead of checked.
-		const pm = await runWithPlan((p) => {
-			twoStepPlan(p)
-			p.updateStepStatus('step_1', 'completed')
-		})
-
-		expect(pm.active?.status).toBe('executing')
-	})
-
-	it('does nothing when the run had no plan at all', async () => {
-		const pm = await runWithPlan(() => {})
-
-		expect(pm.active).toBeNull()
-	})
-})