@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/long-document-flow.test.ts

@@ -1,187 +0,0 @@
-import { readFile, rm } from 'node:fs/promises'
-import { mkdtemp } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { ToolRegistry } from '../../../registry/tool/execute.js'
-import { EditTool, WriteFileTool } from '../../../tools/builtins/index.js'
-import type { SessionId, TenantId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { LLMProvider, StreamChunk } 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'
-
-const ZERO_USAGE = {
-	promptTokens: 0,
-	completionTokens: 0,
-	totalTokens: 0,
-	cachedTokens: 0,
-	cacheWriteTokens: 0,
-}
-
-interface ToolStep {
-	readonly name: string
-	readonly input: Record<string, unknown>
-}
-
-class ScriptedLongDocumentProvider implements LLMProvider {
-	readonly id = 'scripted-long-document'
-	readonly name = 'Scripted Long Document Provider'
-	calls = 0
-
-	constructor(private readonly steps: readonly ToolStep[]) {}
-
-	async *chatStream(): AsyncIterable<StreamChunk> {
-		const step = this.steps[this.calls]
-		this.calls += 1
-
-		if (!step) {
-			yield {
-				id: 'msg_done',
-				delta: { content: 'Long document created and verified.' },
-				finishReason: 'stop',
-				usage: ZERO_USAGE,
-			}
-			return
-		}
-
-		yield {
-			id: `msg_${this.calls}`,
-			delta: {
-				toolCalls: [
-					{
-						index: 0,
-						id: `toolu_${this.calls}`,
-						type: 'function',
-						function: { name: step.name },
-					},
-				],
-			},
-		}
-		yield {
-			id: `msg_${this.calls}`,
-			delta: {
-				toolCalls: [
-					{
-						index: 0,
-						id: `toolu_${this.calls}`,
-						function: { arguments: JSON.stringify(step.input) },
-					},
-				],
-			},
-		}
-		yield {
-			id: `msg_${this.calls}`,
-			delta: {},
-			finishReason: 'tool_calls',
-			usage: ZERO_USAGE,
-		}
-	}
-}
-
-describe('query long-document tool flow', () => {
-	const workdirs: string[] = []
-
-	afterEach(async () => {
-		await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })))
-		workdirs.length = 0
-	})
-
-	it('executes the canonical write skeleton plus bounded edit chunks flow end to end', async () => {
-		const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-query-long-doc-'))
-		workdirs.push(workingDirectory)
-
-		const chunks = Array.from({ length: 4 }, (_, sectionIndex) => {
-			const lines = Array.from({ length: 40 }, (_, lineIndex) => {
-				return `Section ${sectionIndex + 1}.${lineIndex + 1}: this content is intentionally long enough to require repeated bounded edit calls.`
-			})
-			const chunk = [`## Section ${sectionIndex + 1}`, ...lines, ''].join('\n')
-			expect(chunk.length).toBeLessThan(12_000)
-			return chunk
-		})
-
-		const provider = new ScriptedLongDocumentProvider([
-			{
-				name: 'write',
-				input: {
-					path: 'outputs/long-document-flow.md',
-					content: '# Long document flow\n\n{{CHUNK_001}}\n',
-				},
-			},
-			...chunks.map((chunk, index) => ({
-				name: 'edit',
-				input: {
-					path: 'outputs/long-document-flow.md',
-					old_string: `{{CHUNK_${String(index + 1).padStart(3, '0')}}}`,
-					new_string: `${chunk}\n{{CHUNK_${String(index + 2).padStart(3, '0')}}}`,
-					replace_all: false,
-				},
-			})),
-			{
-				name: 'edit',
-				input: {
-					path: 'outputs/long-document-flow.md',
-					old_string: `{{CHUNK_${String(chunks.length + 1).padStart(3, '0')}}}`,
-					new_string: '',
-					replace_all: false,
-				},
-			},
-		])
-		const tools = new ToolRegistry()
-		tools.register(WriteFileTool)
-		tools.register(EditTool)
-		const events: RunEvent[] = []
-
-		const run = await drainQuery(
-			{
-				provider,
-				tools,
-				runConfig: {
-					model: 'mock-model',
-					// The RUN's own deadline, not the test's. This test asserts a
-					// flow, never a latency, so the deadline must sit far above
-					// the work: six model turns and five file edits take ~3s
-					// alone and longer under a parallel suite. The outer vitest
-					// timeout was raised for exactly that reason and this one was
-					// missed, so the run kept aborting itself at 5s and the
-					// failure read as a broken flow rather than a slow machine.
-					timeoutMs: 120_000,
-					tokenBudget: 100_000,
-					maxIterations: 8,
-					maxResponseTokens: 256,
-				},
-				agentId: 'agent_long_doc',
-				agentName: 'Long Document Agent',
-				messages: [createUserMessage('create a long document')],
-				workingDirectory,
-				sessionId: 'ses_long_document_flow' as SessionId,
-				threadId: 'thd_long_document_flow' as ThreadId,
-				projectId: 'prj_long_document_flow' as ProjectId,
-				tenantId: 'tnt_long_document_flow' as TenantId,
-			},
-			(event) => {
-				events.push(event)
-			},
-		)
-
-		const final = await readFile(join(workingDirectory, 'outputs/long-document-flow.md'), 'utf-8')
-		const executingTools = events
-			.filter(
-				(event): event is Extract<RunEvent, { type: 'tool_executing' }> =>
-					event.type === 'tool_executing',
-			)
-			.map((event) => event.toolName)
-
-		expect(run.status).toBe('completed')
-		expect(run.result).toBe('Long document created and verified.')
-		expect(provider.calls).toBe(7)
-		expect(executingTools).toEqual(['write', 'edit', 'edit', 'edit', 'edit', 'edit'])
-		expect(final).not.toContain('{{CHUNK_')
-		expect(final.split('\n').length).toBeGreaterThan(160)
-		expect(final).toContain('## Section 1')
-		expect(final).toContain('## Section 4')
-		expect(final).toContain('Section 4.40')
-	}, 60_000)
-})

package/src/runtime/query/__tests__/memory-promotion.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { MockLLMProvider, registerMock } from '../../../provider/index.js'
-import { ToolRegistry } from '../../../registry/index.js'
-import type { RunMemoryCandidate } from '../../../types/run/memory-promotion.js'
-import { memoryCandidateFor } from '../../../types/run/memory-promotion.js'
-import {
-	generateProjectId,
-	generateSessionId,
-	generateTenantId,
-	generateThreadId,
-} from '../../../utils/id.js'
-import { drainQuery } from '../index.js'
-
-/**
- * namzu could STORE a memory and could not FORM one. `MemoryStore` and
- * its disk implementation have been here all along, and the only path
- * into them was the model calling `save_memory` — so a run that worked
- * out a durable fact and never thought to write it down lost it at
- * settle, along with everything the compaction pass had already
- * extracted and structured on the way.
- */
-
-registerMock()
-
-function run(opts: {
-	promoteMemory?: (candidate: RunMemoryCandidate) => void | Promise<void>
-	failing?: boolean
-	compaction?: boolean
-}) {
-	return drainQuery({
-		provider: new MockLLMProvider({
-			turns: opts.failing ? [{ error: { message: 'provider is down' } }] : [{ text: 'done' }],
-		}),
-		tools: new ToolRegistry(),
-		agentId: 'a',
-		agentName: 'A',
-		messages: [{ role: 'user', content: 'ship the invoice job' }],
-		workingDirectory: process.cwd(),
-		runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 2 },
-		projectId: generateProjectId(),
-		sessionId: generateSessionId(),
-		threadId: generateThreadId(),
-		tenantId: generateTenantId(),
-		...(opts.compaction === false ? {} : { compactionConfig: { strategy: 'structured' } }),
-		...(opts.promoteMemory ? { promoteMemory: opts.promoteMemory } : {}),
-	} as never)
-}
-
-describe('what a finished run leaves behind', () => {
-	it('offers the extracted state when the run settles', async () => {
-		const promote = vi.fn()
-		await run({ promoteMemory: promote })
-
-		expect(promote).toHaveBeenCalledTimes(1)
-		const candidate = promote.mock.calls[0]?.[0] as RunMemoryCandidate
-		expect(candidate.runId).toMatch(/^run_/)
-		expect(candidate.task).toContain('invoice')
-	})
-
-	it('offers it after a FAILED run too', async () => {
-		// A run that fell over still discovered things, and the approach that
-		// failed is exactly what a later run should not pay for twice.
-		const promote = vi.fn()
-		await run({ promoteMemory: promote, failing: true }).catch(() => {})
-
-		expect(promote).toHaveBeenCalledTimes(1)
-	})
-
-	it('does not retract an answer when the host throws', async () => {
-		// A memory that failed to form must not fail a run that already
-		// produced its answer.
-		const settled = await run({
-			promoteMemory: () => {
-				throw new Error('the memory store is unreachable')
-			},
-		})
-
-		expect(settled.status).toBe('completed')
-		expect(settled.result).toBe('done')
-	})
-
-	it('awaits an async host before the run returns', async () => {
-		// Fire-and-forget would race a one-shot process exiting, and the
-		// write would be lost precisely on the runs that are shortest.
-		// Asserted as an ORDER, not a flag: a flag checked after the run
-		// passes whenever the run happens to be slower than the write, which
-		// makes the test a race rather than a check.
-		const order: string[] = []
-		await run({
-			promoteMemory: async () => {
-				await new Promise((resolve) => setTimeout(resolve, 50))
-				order.push('promoted')
-			},
-		})
-		order.push('returned')
-
-		expect(order).toEqual(['promoted', 'returned'])
-	})
-
-	it('is not consulted when no host asked for it', async () => {
-		const settled = await run({})
-
-		expect(settled.status).toBe('completed')
-	})
-
-	it('is not consulted when nothing extracted the state', async () => {
-		const promote = vi.fn()
-		await run({ promoteMemory: promote, compaction: false })
-
-		expect(promote).not.toHaveBeenCalled()
-	})
-})
-
-describe('whether there is anything to offer', () => {
-	// Tested apart from the run because inside the `try` the decision and
-	// the catch that swallows its failure look identical from outside: drop
-	// the guard and the candidate throws, the catch logs, and the run-level
-	// assertion still holds for the wrong reason.
-
-	it('is nothing at all without an extractor', () => {
-		// Inventing an empty candidate would ask a host to store a record of
-		// nothing.
-		expect(memoryCandidateFor('run_1' as never, undefined)).toBeUndefined()
-	})
-
-	it('projects the state rather than handing it over', () => {
-		const state = {
-			task: 'ship it',
-			decisions: ['use the queue'],
-			discoveries: [],
-			userRequirements: ['never bill twice'],
-			failures: [],
-			environment: [],
-			files: new Map([['src/a.ts', {}]]),
-			evicted: { decisions: 2 },
-		}
-		const candidate = memoryCandidateFor('run_1' as never, { getState: () => state })
-
-		expect(candidate?.files).toEqual(['src/a.ts'])
-		expect(candidate?.userRequirements).toEqual(['never bill twice'])
-		// Copied, so a host holding the candidate cannot edit the run's state.
-		expect(candidate?.decisions).not.toBe(state.decisions)
-		// Carried rather than hidden: a host deciding whether this is worth
-		// storing should know it is looking at a truncated record.
-		expect(candidate?.evicted).toEqual({ decisions: 2 })
-	})
-})

package/src/runtime/query/__tests__/orphan-task-turn-end.test.ts

@@ -1,101 +0,0 @@
-import { rm } from 'node:fs/promises'
-import { mkdtemp } 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 { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
-import type { SessionId, TaskId, TenantId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { RunEvent } from '../../../types/run/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/** Ends its turn with plain text on the first (and only) call. */
-/**
- * Gateway that permanently reports one running task. Every dispatch
- * tool is blocking, so a running task at end-of-turn is an orphan —
- * there is no notification producer that could ever deliver its
- * result (the listener was removed in dc16d58). The run must NOT
- * busy-wait on it.
- */
-function orphanTaskGateway(): TaskGateway {
-	const handle: TaskHandle = {
-		taskId: 'task_orphan' as TaskId,
-		agentId: 'agent_worker',
-		state: 'running',
-		createdAt: Date.now(),
-	}
-	return {
-		createTask: async () => handle,
-		waitForTask: () => new Promise<TaskHandle>(() => {}),
-		continueTask: async () => {},
-		cancelTask: () => {},
-		getTask: () => handle,
-		listTasks: () => [handle],
-		onTaskCompleted: () => () => {},
-	}
-}
-
-describe('end of turn with running agent tasks', () => {
-	let workdirs: string[] = []
-
-	afterEach(async () => {
-		await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })))
-		workdirs = []
-	})
-
-	// Regression: the loop used to poll `pendingNotifications` every
-	// 250ms for up to `runConfig.timeoutMs` (120s default) whenever the
-	// turn ended while the gateway still listed a running task — but
-	// nothing has pushed onto that queue since dc16d58 removed the
-	// onTaskCompleted producer, so the wait always injected nothing and
-	// the run hung for minutes. The vitest per-test timeout is the
-	// hang detector here: with the busy-wait present this test times
-	// out instead of completing.
-	it('ends the run promptly instead of busy-waiting on orphan tasks', async () => {
-		// One text turn, no tools — the mock's default script shape.
-		const provider = new MockLLMProvider({ turns: [{ text: 'Final answer.' }] })
-		const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-orphan-task-'))
-		workdirs.push(workingDirectory)
-		const events: RunEvent[] = []
-
-		const run = await drainQuery(
-			{
-				provider,
-				tools: new ToolRegistry(),
-				runConfig: {
-					model: 'mock-model',
-					// Deliberately longer than the vitest timeout: the old
-					// code waited min(timeoutMs, …) polling the dead queue.
-					timeoutMs: 120_000,
-					tokenBudget: 100_000,
-					maxIterations: 3,
-					maxResponseTokens: 256,
-				},
-				agentId: 'agent_test',
-				agentName: 'Test Agent',
-				messages: [createUserMessage('do the thing')],
-				workingDirectory,
-				taskGateway: orphanTaskGateway(),
-				sessionId: 'ses_orphan_task' as SessionId,
-				threadId: 'thd_orphan_task' as ThreadId,
-				projectId: 'prj_orphan_task' as ProjectId,
-				tenantId: 'tnt_orphan_task' as TenantId,
-			},
-			(event) => {
-				events.push(event)
-			},
-		)
-
-		expect(run.status).toBe('completed')
-		expect(run.stopReason).toBe('end_turn')
-		expect(run.result).toBe('Final answer.')
-		// One turn only — no futile re-invocation loop on the orphan.
-		// Exactly one model call: the run must NOT busy-wait on the orphan.
-		expect(provider.requests).toHaveLength(1)
-		expect(events.some((event) => event.type === 'run_failed')).toBe(false)
-	}, 10_000)
-})

package/src/runtime/query/__tests__/overflow-relief.test.ts

@@ -1,139 +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 { ChatCompletionParams, StreamChunk } from '../../../types/provider/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { drainQuery } from '../index.js'
-
-/**
- * `context_length_exceeded` is the one provider failure the kernel can act
- * on. It is correctly non-retryable — resending the identical prompt
- * cannot help — and the kernel classified it precisely and then let the
- * run die, while holding a compaction subsystem that could have made room.
- *
- * The threshold path guesses when to compact and can guess low, so this is
- * not a hypothetical: a run carrying images, or a language the
- * chars-per-token ratio does not fit, reaches the real window while still
- * reading as comfortable.
- */
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-/** Overflows until the prompt shrinks, then answers. */
-class OverflowingProvider extends MockLLMProvider {
-	seen: number[] = []
-	constructor(private readonly limitChars: number) {
-		super({ turns: [{ text: 'answered after relief' }] })
-	}
-
-	override async *chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
-		const size = params.messages.reduce(
-			(n, m) => n + (typeof m.content === 'string' ? m.content.length : 0),
-			0,
-		)
-		this.seen.push(size)
-		if (size > this.limitChars) {
-			throw Object.assign(new Error('prompt is too long for this model: context_length_exceeded'), {
-				status: 400,
-			})
-		}
-		yield* super.chatStream(params)
-	}
-}
-
-async function run(provider: MockLLMProvider, compaction: boolean) {
-	const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-overflow-'))
-	dirs.push(workingDirectory)
-
-	// A history big enough that shedding it changes the prompt size.
-	const messages = Array.from({ length: 12 }, (_, i) =>
-		createUserMessage(`turn ${i}: ${'context '.repeat(400)}`),
-	)
-
-	return drainQuery({
-		provider,
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 20_000,
-			tokenBudget: 500_000,
-			maxIterations: 6,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_o',
-		agentName: 'Overflow',
-		messages,
-		workingDirectory,
-		sessionId: 'ses_o' as SessionId,
-		threadId: 'thd_o' as ThreadId,
-		projectId: 'prj_o' as ProjectId,
-		tenantId: 'tnt_o' as TenantId,
-		retry: false,
-		...(compaction
-			? {
-					compactionConfig: {
-						strategy: 'structured' as const,
-						triggerThreshold: 0.7,
-						resetThreshold: 0.4,
-						keepRecentMessages: 2,
-						clearToolResults: true,
-						keepRecentToolResults: 3,
-						minToolResultCharsToClear: 1_000,
-						maxToolResults: 30,
-						maxListSize: 25,
-						keepFirstEntries: 3,
-						llmVerification: false,
-						llmVerificationMaxTokens: 2048,
-						richStateThreshold: 15,
-						convoTextBudget: 12_000,
-						maxSentencesPerTurn: 5,
-						maxCharsPerNote: 500,
-						maxCharsPerRequirement: 300,
-						maxCharsPerTask: 400,
-					} as never,
-				}
-			: {}),
-	})
-}
-
-describe('a context overflow is relieved rather than fatal', () => {
-	it('compacts and completes instead of dying', async () => {
-		const provider = new OverflowingProvider(20_000)
-		const result = await run(provider, true)
-
-		// Two attempts: the one that overflowed, and the one after relief.
-		expect(provider.seen.length).toBeGreaterThanOrEqual(2)
-		expect(provider.seen[1]).toBeLessThan(provider.seen[0] as number)
-		expect(result.result).toBe('answered after relief')
-		expect(result.stopReason).toBe('end_turn')
-	})
-
-	it('still fails when there is no compaction configured to shed with', async () => {
-		// Relief must not be claimed when nothing can be shed — retrying
-		// would send the identical prompt and arrive at the identical error.
-		const provider = new OverflowingProvider(20_000)
-		const result = await run(provider, false)
-
-		expect(result.status).toBe('failed')
-		expect(provider.seen).toHaveLength(1)
-	})
-
-	it('does not interfere with a run that never overflows', async () => {
-		const provider = new OverflowingProvider(10_000_000)
-		const result = await run(provider, true)
-
-		expect(provider.seen).toHaveLength(1)
-		expect(result.result).toBe('answered after relief')
-	})
-})