@namzu/sdk 14.0.7 → 15.0.0

package/src/compaction/__tests__/state-across-resume.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { CompactionConfig } from '../../config/runtime.js'
-import { WorkingStateManager } from '../manager.js'
-import { serializeState } from '../serializer.js'
-import { restoreWorkingState, snapshotWorkingState } from '../wire.js'
-
-/**
- * Compaction replaces older history with a summary and drops any PRIOR
- * summary, on the grounds that `serializeState` is cumulative so the new
- * one supersedes it. Within a process that is true.
- *
- * Across a resume it was not: the manager was rebuilt empty on every
- * `query()`, so a resumed run's second compaction summarized only
- * post-resume activity and deleted the block holding everything before it
- * — the block the restore path had deliberately carried forward as the
- * only surviving record of the compacted history.
- */
-
-function config(): CompactionConfig {
-	return {
-		strategy: 'structured',
-		triggerThreshold: 0.7,
-		resetThreshold: 0.4,
-		keepRecentMessages: 4,
-		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 CompactionConfig
-}
-
-/** A manager holding the kind of state a first hour of work produces. */
-function firstHour(): WorkingStateManager {
-	const m = new WorkingStateManager(config())
-	m.setTask('migrate the billing schema')
-	m.addDecision('chose an additive migration over a rewrite')
-	m.addFailure('the first attempt deadlocked on the invoices table')
-	m.addDiscovery('invoices has a partial index nobody documented')
-	m.trackFile('src/billing/schema.ts', { type: 'edit', detail: 'added the additive columns' })
-	return m
-}
-
-describe('working state survives a process boundary', () => {
-	it('round-trips every slot', () => {
-		const before = firstHour()
-		const after = restoreWorkingState(snapshotWorkingState(before), config())
-
-		expect(serializeState(after.getState())).toBe(serializeState(before.getState()))
-	})
-
-	it('carries the file map, which JSON alone would flatten to nothing', () => {
-		// `WorkingState.files` is a Map. `JSON.stringify` renders a Map as
-		// `{}`, so a naive snapshot would silently lose every tracked file.
-		const restored = restoreWorkingState(snapshotWorkingState(firstHour()), config())
-		expect(restored.getState().files.get('src/billing/schema.ts')).toBeDefined()
-	})
-
-	it('carries the eviction counters, so a resumed summary still admits its losses', () => {
-		// The state that survives compaction is the only record of the
-		// history it replaced. A resumed summary that forgot what it had
-		// already dropped would claim a completeness it does not have.
-		const m = new WorkingStateManager(config())
-		for (let i = 0; i < 40; i++) m.addDecision(`decision ${i}`)
-		expect(m.getState().evicted.decisions).toBeGreaterThan(0)
-
-		const restored = restoreWorkingState(snapshotWorkingState(m), config())
-		expect(restored.getState().evicted.decisions).toBe(m.getState().evicted.decisions)
-	})
-
-	it('keeps accumulating after the restore rather than starting over', () => {
-		// This is the property the whole fix exists for: the SECOND
-		// compaction of a resumed run must summarize the first hour AND what
-		// followed, because it is about to delete the block that held the
-		// first hour.
-		const restored = restoreWorkingState(snapshotWorkingState(firstHour()), config())
-		restored.addDecision('after the resume, switched to a batched backfill')
-
-		const serialized = serializeState(restored.getState())
-		expect(serialized).toContain('additive migration')
-		expect(serialized).toContain('batched backfill')
-	})
-
-	it('an empty snapshot restores to an empty manager', () => {
-		const empty = new WorkingStateManager(config())
-		const restored = restoreWorkingState(snapshotWorkingState(empty), config())
-		expect(restored.slotCount()).toBe(empty.slotCount())
-	})
-})

package/src/compaction/__tests__/tool-result-editing.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { Message } from '../../types/message/index.js'
-import { clearStaleToolResults, isClearedToolResult } from '../tool-result-editing.js'
-
-/**
- * Compaction was all-or-nothing: once the threshold hit, every older
- * message became a summary and the agent's own reasoning — the decisions,
- * the false starts it learned from, the exact wording of a plan — was
- * paraphrased away with it.
- *
- * That is a heavy price for a context problem usually caused by something
- * much dumber: a handful of enormous tool outputs the agent already read,
- * took what it needed from, and moved past.
- */
-
-const big = (n: number) => 'x'.repeat(n)
-
-function conversation(
-	results: Array<{ tool: string; output: string; isError?: boolean }>,
-): Message[] {
-	const messages: Message[] = [{ role: 'system', content: 'you are an agent' }]
-	results.forEach((r, i) => {
-		messages.push({
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{ id: `call_${i}`, type: 'function', function: { name: r.tool, arguments: '{}' } },
-			],
-		} as Message)
-		messages.push({
-			role: 'tool',
-			content: r.output,
-			toolCallId: `call_${i}`,
-			...(r.isError ? { isError: true } : {}),
-		} as Message)
-	})
-	return messages
-}
-
-describe('clearStaleToolResults', () => {
-	it('clears an old, large result and leaves a placeholder naming the tool', () => {
-		const messages = conversation([
-			{ tool: 'read_file', output: big(50_000) },
-			{ tool: 'ls', output: 'a.ts' },
-			{ tool: 'ls', output: 'b.ts' },
-			{ tool: 'ls', output: 'c.ts' },
-		])
-
-		const { messages: edited, clearedCount, charsReclaimed } = clearStaleToolResults(messages)
-
-		expect(clearedCount).toBe(1)
-		expect(charsReclaimed).toBeGreaterThan(49_000)
-		const cleared = edited.find((m) => m.role === 'tool' && isClearedToolResult(m.content))
-		expect(cleared?.content).toContain('read_file')
-		expect(cleared?.content).toContain('50,000 characters')
-	})
-
-	it('keeps `tool_use` ↔ `tool_result` pairing intact — nothing moves', () => {
-		// This is what makes clearing safe where trimming is not.
-		const messages = conversation([
-			{ tool: 'read_file', output: big(50_000) },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-
-		const { messages: edited } = clearStaleToolResults(messages)
-
-		expect(edited).toHaveLength(messages.length)
-		edited.forEach((msg, i) => {
-			expect(msg.role).toBe(messages[i]?.role)
-			if (msg.role === 'tool') {
-				expect(msg.toolCallId).toBe((messages[i] as { toolCallId: string }).toolCallId)
-			}
-		})
-	})
-
-	it('does not mutate the input', () => {
-		const messages = conversation([
-			{ tool: 'read_file', output: big(50_000) },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-		const before = JSON.stringify(messages)
-		clearStaleToolResults(messages)
-		expect(JSON.stringify(messages)).toBe(before)
-	})
-
-	it('leaves the most recent results alone — the agent is still using them', () => {
-		const messages = conversation([
-			{ tool: 'a', output: big(20_000) },
-			{ tool: 'b', output: big(20_000) },
-			{ tool: 'c', output: big(20_000) },
-			{ tool: 'd', output: big(20_000) },
-		])
-
-		const { clearedCount, messages: edited } = clearStaleToolResults(messages, {
-			keepRecentToolResults: 3,
-		})
-
-		expect(clearedCount).toBe(1)
-		// The last three are untouched.
-		const toolMsgs = edited.filter((m) => m.role === 'tool')
-		expect(toolMsgs.slice(1).every((m) => !isClearedToolResult(m.content))).toBe(true)
-	})
-
-	it('leaves small results alone — the placeholder would cost as much', () => {
-		const messages = conversation([
-			{ tool: 'ls', output: 'a.ts b.ts' },
-			{ tool: 'ls', output: 'c.ts' },
-			{ tool: 'ls', output: 'd.ts' },
-			{ tool: 'ls', output: 'e.ts' },
-		])
-		expect(clearStaleToolResults(messages).clearedCount).toBe(0)
-	})
-
-	it('never clears an ERROR result — the error is what steers the next turn', () => {
-		const messages = conversation([
-			{ tool: 'bash', output: big(50_000), isError: true },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-		expect(clearStaleToolResults(messages).clearedCount).toBe(0)
-	})
-
-	it('honors a preserve list, by tool name', () => {
-		const messages = conversation([
-			{ tool: 'load_spec', output: big(50_000) },
-			{ tool: 'read_file', output: big(50_000) },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-
-		const { clearedCount, messages: edited } = clearStaleToolResults(messages, {
-			preserveTools: ['load_spec'],
-		})
-
-		expect(clearedCount).toBe(1)
-		const specResult = edited.find((m) => m.role === 'tool' && m.toolCallId === 'call_0')
-		expect(isClearedToolResult(specResult?.content)).toBe(false)
-	})
-
-	it('is idempotent — a second pass finds nothing left to do', () => {
-		const messages = conversation([
-			{ tool: 'read_file', output: big(50_000) },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-
-		const first = clearStaleToolResults(messages)
-		const second = clearStaleToolResults(first.messages)
-		expect(second.clearedCount).toBe(0)
-		expect(second.charsReclaimed).toBe(0)
-	})
-
-	it('reports the NET saving, not the gross one', () => {
-		// A caller uses this number to decide "was that enough?", so
-		// overstating it would send it back to summarize when it need not.
-		const messages = conversation([
-			{ tool: 'read_file', output: big(10_000) },
-			{ tool: 'ls', output: 'a' },
-			{ tool: 'ls', output: 'b' },
-			{ tool: 'ls', output: 'c' },
-		])
-
-		const { messages: edited, charsReclaimed } = clearStaleToolResults(messages)
-		const placeholder = edited.find((m) => m.role === 'tool' && isClearedToolResult(m.content))
-		const placeholderLength = String(placeholder?.content).length
-
-		expect(charsReclaimed).toBe(10_000 - placeholderLength)
-	})
-
-	it('measures an image result by its payload, which is the biggest win available', () => {
-		// A screenshot is the single largest thing a tool result can carry,
-		// and exactly the kind of output an agent reads once.
-		const messages: Message[] = [
-			{
-				role: 'assistant',
-				content: null,
-				toolCalls: [
-					{ id: 'call_s', type: 'function', function: { name: 'screenshot', arguments: '{}' } },
-				],
-			} as Message,
-			{
-				role: 'tool',
-				content: [{ type: 'image', data: big(400_000), mediaType: 'image/png' }],
-				toolCallId: 'call_s',
-			} as Message,
-		]
-
-		const { clearedCount, charsReclaimed } = clearStaleToolResults(messages, {
-			keepRecentToolResults: 0,
-		})
-		expect(clearedCount).toBe(1)
-		expect(charsReclaimed).toBeGreaterThan(399_000)
-	})
-
-	it('does nothing to a conversation with no tool results', () => {
-		const messages: Message[] = [
-			{ role: 'system', content: 'sys' },
-			{ role: 'user', content: 'hello' },
-			{ role: 'assistant', content: 'hi' } as Message,
-		]
-		const out = clearStaleToolResults(messages)
-		expect(out.clearedCount).toBe(0)
-		expect(out.messages).toEqual(messages)
-	})
-})

package/src/compaction/__tests__/trim-opens-on-user.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { Message } from '../../types/message/index.js'
-import { findSafeTrimIndex } from '../dangling.js'
-
-/**
- * After compaction the kept tail IS the conversation: the summary is
- * written as a system message and every driver hoists system messages into
- * their own request parameter, so the first kept message becomes the first
- * message on the wire. A conversation that opens on an assistant turn is
- * rejected.
- *
- * `findSafeTrimIndex` advanced past an orphaned `tool` message and never
- * past an `assistant` one. How often that bit depends on the shape of the
- * history, and the shape that matters most is the worst: in a multi-step
- * turn — the agent working through several tool calls without the user
- * speaking in between — the tail alternates assistant/tool with no user
- * message in it at all, so essentially every boundary landed wrong.
- *
- * The failure was unrecoverable, too. The resulting rejection is not
- * classified as an overflow, so relief never fires and the run dies —
- * compaction, whose whole job is keeping a long run alive, becoming the
- * thing that ends it.
- */
-
-const user = (text: string): Message => ({ role: 'user', content: text })
-const answer = (text: string): Message => ({ role: 'assistant', content: text })
-const calls = (id: string): Message => ({
-	role: 'assistant',
-	content: null,
-	toolCalls: [{ id, type: 'function', function: { name: 't', arguments: '{}' } }],
-})
-const result = (id: string): Message => ({ role: 'tool', toolCallId: id, content: 'ok' })
-
-/** user → assistant(call) → tool → assistant(answer), repeated. */
-function conversational(turns: number): Message[] {
-	const out: Message[] = []
-	for (let i = 0; i < turns; i++) {
-		out.push(user(`q${i}`), calls(`c${i}`), result(`c${i}`), answer(`a${i}`))
-	}
-	return out
-}
-
-/** One user turn, then the agent working alone — the normal agentic shape. */
-function multiStep(steps: number): Message[] {
-	const out: Message[] = [user('go')]
-	for (let i = 0; i < steps; i++) out.push(calls(`c${i}`), result(`c${i}`))
-	out.push(answer('done'))
-	return out
-}
-
-/** Two tool calls per turn, which shifts the parity of every boundary. */
-function wideTurns(turns: number): Message[] {
-	const out: Message[] = []
-	for (let i = 0; i < turns; i++) {
-		out.push(user(`q${i}`), {
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{ id: `c${i}a`, type: 'function', function: { name: 't', arguments: '{}' } },
-				{ id: `c${i}b`, type: 'function', function: { name: 't', arguments: '{}' } },
-			],
-		})
-		out.push(result(`c${i}a`), result(`c${i}b`), answer(`a${i}`))
-	}
-	return out
-}
-
-describe('the kept tail opens the way a conversation opens', () => {
-	it.each([
-		['one tool call per turn', conversational(6)],
-		['two tool calls per turn', wideTurns(6)],
-		['a multi-step turn with no user in between', multiStep(6)],
-	])('%s', (_name, messages) => {
-		for (let keep = 1; keep <= Math.min(12, messages.length); keep++) {
-			const index = findSafeTrimIndex(messages, messages.length - keep)
-			const kept = messages.slice(index)
-			if (kept.length === 0) continue
-			expect(kept[0]?.role).toBe('user')
-		}
-	})
-
-	it('is wrong at every boundary in a multi-step turn without the guard', () => {
-		// Recorded so the regression is legible: this shape has exactly one
-		// user message, at the front, and the whole tail after it alternates
-		// assistant and tool. Any boundary inside it lands on the wrong role.
-		const messages = multiStep(6)
-		const userTurns = messages.filter((m) => m.role === 'user')
-		expect(userTurns).toHaveLength(1)
-		expect(messages.indexOf(userTurns[0] as Message)).toBe(0)
-
-		for (let keep = 1; keep < messages.length; keep++) {
-			const index = findSafeTrimIndex(messages, messages.length - keep)
-			// The only valid boundary in this shape is the very front.
-			expect(index).toBe(0)
-		}
-	})
-})
-
-describe('when no boundary can satisfy both invariants', () => {
-	it('does not re-admit an orphaned result to reach a user turn', () => {
-		// Already unsendable: the results have no call anywhere. Falling back
-		// to the user message at the front would satisfy "opens on user" by
-		// breaking "no orphaned result", which is not a fix.
-		const messages: Message[] = [user('test'), result('missing-1'), result('missing-2')]
-		const kept = messages.slice(findSafeTrimIndex(messages, 1))
-		expect(kept).toHaveLength(0)
-	})
-
-	it('declines to trim rather than invent a different broken conversation', () => {
-		const messages: Message[] = [user('a'), answer('b')]
-		const index = findSafeTrimIndex(messages, 1)
-		// Index 1 is the assistant. Forward reaches the end; back reaches the
-		// user at 0, whose tail is clean — so it keeps more than asked.
-		expect(index).toBe(0)
-		expect(messages.slice(index)[0]?.role).toBe('user')
-	})
-})

package/src/compaction/__tests__/verifier-empty-reply.test.ts

@@ -1,96 +0,0 @@
-/**
- * The EMPTY VERIFIER REPLY.
- *
- * `buildVerifiedSummary` treats only the literal `COMPLETE` as "nothing to add".
- * Anything else is appended under a `## LLM Verification Additions` heading —
- * including the empty string, which is what a truncated turn, a refusal, or an
- * exhausted `llmVerificationMaxTokens` produces. The result is a heading with
- * nothing under it, and because the summary becomes a leading system message it
- * then rides in EVERY subsequent prompt of the run.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import { CompactionConfigSchema } from '../../config/runtime.js'
-import {
-	type Message,
-	createAssistantMessage,
-	createUserMessage,
-} from '../../types/message/index.js'
-import type { ChatCompletionParams } from '../../types/provider/chat.js'
-import type { LLMProvider } from '../../types/provider/interface.js'
-import type { StreamChunk } from '../../types/provider/stream.js'
-import { WorkingStateManager } from '../manager.js'
-import { buildVerifiedSummary } from '../verifier.js'
-
-const ADDITIONS_HEADING = '## LLM Verification Additions'
-
-function makeProvider(chunks: StreamChunk[]): LLMProvider & { calls: ChatCompletionParams[] } {
-	const calls: ChatCompletionParams[] = []
-	return {
-		id: 'mock',
-		name: 'mock',
-		calls,
-		chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
-			calls.push(params)
-			return (async function* () {
-				for (const c of chunks) yield c
-			})()
-		},
-	}
-}
-
-function makeManager() {
-	const config = CompactionConfigSchema.parse({ llmVerification: true })
-	const manager = new WorkingStateManager(config)
-	manager.setTask('write the quarterly report')
-	manager.addDecision('built the report as .docx')
-	return { config, manager }
-}
-
-const OLDER: Message[] = [
-	createUserMessage('write the quarterly report'),
-	createAssistantMessage('on it — reading the source numbers first'),
-]
-
-describe('buildVerifiedSummary — empty verifier reply', () => {
-	it('does not append an empty "Additions" section when the verifier returns nothing', async () => {
-		const { config, manager } = makeManager()
-		const provider = makeProvider([])
-
-		const result = await buildVerifiedSummary(manager, OLDER, provider, config)
-
-		expect(result).not.toContain(ADDITIONS_HEADING)
-	})
-
-	it('does not append an empty "Additions" section when the turn is truncated by maxTokens', async () => {
-		const { config, manager } = makeManager()
-		// `length` finish reason with no content — llmVerificationMaxTokens exhausted.
-		const provider = makeProvider([{ id: 'c1', delta: { content: '' }, finishReason: 'length' }])
-
-		const result = await buildVerifiedSummary(manager, OLDER, provider, config)
-
-		expect(result).not.toContain(ADDITIONS_HEADING)
-	})
-
-	it('does not append an "Additions" section for a whitespace-only reply', async () => {
-		const { config, manager } = makeManager()
-		const provider = makeProvider([{ id: 'c1', delta: { content: '   \n\n  ' } }])
-
-		const result = await buildVerifiedSummary(manager, OLDER, provider, config)
-
-		expect(result).not.toContain(ADDITIONS_HEADING)
-	})
-
-	it('still appends real additions', async () => {
-		const { config, manager } = makeManager()
-		const provider = makeProvider([
-			{ id: 'c1', delta: { content: '- the user asked for EUR, not USD' } },
-		])
-
-		const result = await buildVerifiedSummary(manager, OLDER, provider, config)
-
-		expect(result).toContain(ADDITIONS_HEADING)
-		expect(result).toContain('EUR, not USD')
-	})
-})

package/src/compaction/__tests__/verifier-model.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { CompactionConfig } from '../../config/runtime.js'
-import { MockLLMProvider } from '../../provider/mock.js'
-import type { Message } from '../../types/message/index.js'
-import { WorkingStateManager } from '../manager.js'
-import { buildVerifiedSummary } from '../verifier.js'
-
-/**
- * The compaction verifier called `provider.chatStream({ model: '' })`.
- *
- * Some drivers quietly substitute a default and others reject outright —
- * on Bedrock the model id IS the endpoint, and OpenRouter requires it. So
- * the verifier failed exactly on the providers where a long run most needs
- * compaction, and the failure surfaced as compaction killing the run it
- * exists to save.
- */
-
-function config(overrides: Partial<CompactionConfig> = {}): CompactionConfig {
-	return {
-		strategy: 'structured',
-		triggerThreshold: 0.7,
-		resetThreshold: 0.4,
-		keepRecentMessages: 4,
-		clearToolResults: true,
-		keepRecentToolResults: 3,
-		minToolResultCharsToClear: 1_000,
-		maxToolResults: 30,
-		maxListSize: 25,
-		keepFirstEntries: 3,
-		llmVerification: true,
-		llmVerificationMaxTokens: 2048,
-		richStateThreshold: 15,
-		convoTextBudget: 12_000,
-		maxSentencesPerTurn: 5,
-		maxCharsPerNote: 500,
-		maxCharsPerRequirement: 300,
-		maxCharsPerTask: 400,
-		...overrides,
-	} as CompactionConfig
-}
-
-const older: Message[] = [
-	{ role: 'user', content: 'build the thing' },
-	{ role: 'assistant', content: 'I built it' } as Message,
-]
-
-describe('buildVerifiedSummary', () => {
-	it('sends the run`s model, not an empty string', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'COMPLETE' }] })
-		const manager = new WorkingStateManager(config())
-
-		await buildVerifiedSummary(
-			manager,
-			older,
-			provider,
-			config(),
-			undefined,
-			'anthropic.claude-opus-4-v1',
-		)
-
-		expect(provider.requests).toHaveLength(1)
-		expect(provider.requests[0]?.model).toBe('anthropic.claude-opus-4-v1')
-	})
-
-	it('bills the side-channel call to the run', async () => {
-		// A compaction pass is not free, and a run that cannot see the cost
-		// cannot enforce its own budget.
-		const provider = new MockLLMProvider({ turns: [{ text: 'COMPLETE' }] })
-		const onUsage = vi.fn()
-
-		await buildVerifiedSummary(
-			new WorkingStateManager(config()),
-			older,
-			provider,
-			config(),
-			onUsage,
-			'some-model',
-		)
-
-		expect(onUsage).toHaveBeenCalledOnce()
-	})
-})