@namzu/sdk 14.0.7 → 15.0.0

package/src/compaction/__tests__/cleared-result-recovery.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { SPILL_MARKER } from '../../runtime/query/tool-output-budget.js'
-import type { Message } from '../../types/message/index.js'
-import { clearStaleToolResults, isClearedToolResult } from '../tool-result-editing.js'
-
-/**
- * Clearing replaced the whole content with a placeholder, which destroyed
- * the recovery pointer for exactly the results that most needed one.
- *
- * When a tool result exceeds the output budget its full text is written to
- * disk and a line pointing at it is embedded IN the result. Clearing that
- * result deleted the line — so the largest outputs lost the cheapest way
- * back to them, and the placeholder then advised calling the tool again,
- * which is advice to re-run something that returned megabytes.
- */
-
-function history(resultText: string): Message[] {
-	return [
-		{ role: 'user', content: 'go' },
-		{
-			role: 'assistant',
-			content: null,
-			toolCalls: [{ id: 'c1', type: 'function', function: { name: 'bash', arguments: '{}' } }],
-		},
-		{ role: 'tool', toolCallId: 'c1', content: resultText },
-		{ role: 'user', content: 'next' },
-	] as Message[]
-}
-
-const clear = (messages: Message[]) =>
-	clearStaleToolResults(messages, { keepRecentToolResults: 0, minCharsToClear: 100 })
-
-const clearedText = (messages: Message[]): string => {
-	const tool = messages.find((m) => m.role === 'tool')
-	return String((tool as { content: string }).content)
-}
-
-describe('a spilled result', () => {
-	// The marker sits in the MIDDLE, outside both the head and the tail
-	// window. Left near the end it would ride along in the tail and the
-	// test would pass with the preservation removed.
-	const spilled = [
-		'first line of output',
-		'x'.repeat(5_000),
-		`${SPILL_MARKER} /runs/r1/tool-output/bash-1.txt`,
-		'Read a specific window with `read` (offset/limit) or search it with `grep`.',
-		'y'.repeat(5_000),
-	].join('\n')
-
-	it('keeps the pointer to the spilled file', () => {
-		const { messages } = clear(history(spilled))
-		// The line is the only route back to content the budget
-		// deliberately preserved on disk.
-		expect(clearedText(messages)).toContain('/runs/r1/tool-output/bash-1.txt')
-	})
-
-	it('tells the model to read it rather than re-run the tool', () => {
-		const { messages } = clear(history(spilled))
-		const text = clearedText(messages)
-		expect(text).toMatch(/read|grep/)
-		// Re-running a tool that returned megabytes is the advice this
-		// replaces.
-		expect(text).not.toContain('Call the tool again')
-	})
-
-	it('still reclaims most of the content', () => {
-		const { charsReclaimed, clearedCount } = clear(history(spilled))
-		expect(clearedCount).toBe(1)
-		expect(charsReclaimed).toBeGreaterThan(4_000)
-	})
-})
-
-describe('an ordinary large result', () => {
-	const long = `HEAD-MARKER\n${'y'.repeat(5_000)}\nTAIL-MARKER`
-
-	it('keeps a readable head and tail', () => {
-		const text = clearedText(clear(history(long)).messages)
-		// A result is not uniformly valuable; what a model needs is usually
-		// near one end.
-		expect(text).toContain('HEAD-MARKER')
-		expect(text).toContain('TAIL-MARKER')
-	})
-
-	it('says how much it elided', () => {
-		expect(clearedText(clear(history(long)).messages)).toMatch(/characters elided/)
-	})
-
-	it('still advises re-running when there is nothing on disk', () => {
-		expect(clearedText(clear(history(long)).messages)).toContain('Call the tool again')
-	})
-
-	it('is still recognisable as cleared', () => {
-		// A second pass must not clear its own placeholder again.
-		const once = clear(history(long)).messages
-		expect(isClearedToolResult(clearedText(once))).toBe(true)
-		expect(clear(once).clearedCount).toBe(0)
-	})
-
-	it('reclaims more than it keeps', () => {
-		const { charsReclaimed } = clear(history(long))
-		expect(charsReclaimed).toBeGreaterThan(3_000)
-	})
-})
-
-describe('a result barely over the threshold', () => {
-	it('does not lose everything to save a few hundred characters', () => {
-		const short = `IMPORTANT-FIRST-LINE\n${'z'.repeat(200)}\nIMPORTANT-LAST-LINE`
-		const { messages } = clearStaleToolResults(history(short), {
-			keepRecentToolResults: 0,
-			minCharsToClear: 100,
-		})
-		const text = clearedText(messages)
-		// The three lines the agent was reasoning from used to go with it.
-		expect(text).toContain('IMPORTANT-FIRST-LINE')
-		expect(text).toContain('IMPORTANT-LAST-LINE')
-	})
-})

package/src/compaction/__tests__/context-reducer.test.ts

@@ -1,239 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { AssistantMessage, Message, ToolMessage } from '../../types/message/index.js'
-import { createSlidingWindowReducer } from '../reducer.js'
-import type { ContextReduction } from '../reducer.js'
-
-/**
- * `strategy: 'sliding-window'` was accepted by the config schema and then
- * ignored — the runtime asked only whether the strategy was `'disabled'`, so
- * a host who chose the cheap non-LLM path silently got the expensive LLM one,
- * summarization calls and all. These pin the behaviour the name always
- * claimed, and the three invariants that make a shorter history usable rather
- * than merely shorter.
- */
-
-const sys = (content: string): Message => ({ role: 'system', content, timestamp: 1 })
-const user = (content: string): Message => ({ role: 'user', content, timestamp: 1 })
-const asst = (content: string): Message => ({ role: 'assistant', content, timestamp: 1 })
-
-const callsTool = (id: string): AssistantMessage => ({
-	role: 'assistant',
-	content: null,
-	timestamp: 1,
-	toolCalls: [{ id, type: 'function', function: { name: 'echo', arguments: '{}' } }],
-})
-
-const toolResult = (id: string): ToolMessage => ({
-	role: 'tool',
-	content: 'ok',
-	timestamp: 1,
-	toolCallId: id,
-})
-
-function reduction(
-	messages: readonly Message[],
-	over?: Partial<ContextReduction>,
-): ContextReduction {
-	return {
-		messages,
-		reason: 'threshold',
-		estimatedTokens: 1_000,
-		contextWindowTokens: 2_000,
-		model: 'mock-model',
-		keepRecentMessages: 4,
-		...over,
-	}
-}
-
-describe('the sliding window keeps recent turns and drops the rest', () => {
-	it('keeps the configured tail', async () => {
-		const reduce = createSlidingWindowReducer()
-		const messages = [sys('prompt'), ...Array.from({ length: 10 }, (_, i) => user(`m${i}`))]
-
-		const next = await reduce(reduction(messages))
-
-		expect(next).toBeDefined()
-		expect(next?.length).toBe(5) // the system floor plus keepRecentMessages
-		expect(next?.at(-1)).toBe(messages.at(-1))
-	})
-
-	it('cuts harder when the provider already rejected the prompt', async () => {
-		const reduce = createSlidingWindowReducer()
-		const messages = [sys('prompt'), ...Array.from({ length: 10 }, (_, i) => user(`m${i}`))]
-
-		const threshold = await reduce(reduction(messages))
-		const overflow = await reduce(reduction(messages, { reason: 'overflow' }))
-
-		// An overflow means the ordinary window was ALREADY too big. Cutting to
-		// the same size would shed nothing and the caller would retry an
-		// identical prompt.
-		expect(overflow?.length).toBeLessThan(threshold?.length ?? 0)
-	})
-
-	it('summarizes nothing — every survivor is the original object', async () => {
-		const reduce = createSlidingWindowReducer()
-		const messages = [sys('prompt'), ...Array.from({ length: 8 }, (_, i) => user(`m${i}`))]
-
-		const next = await reduce(reduction(messages))
-
-		for (const message of next ?? []) expect(messages).toContain(message)
-	})
-})
-
-describe('the three invariants a shorter history has to keep', () => {
-	it('never drops the leading system floor', async () => {
-		const reduce = createSlidingWindowReducer()
-		const messages = [
-			sys('prompt'),
-			sys('working memory'),
-			...Array.from({ length: 8 }, (_, i) => user(`m${i}`)),
-		]
-
-		const next = await reduce(reduction(messages))
-
-		expect(next?.[0]).toBe(messages[0])
-		expect(next?.[1]).toBe(messages[1])
-	})
-
-	it('does not split a tool_use from its tool_result', async () => {
-		const reduce = createSlidingWindowReducer()
-		// The naive cut at length-3 lands between the assistant call and its
-		// result, which is a provider 400 on the next turn.
-		const messages = [
-			sys('prompt'),
-			user('go'),
-			asst('thinking'),
-			callsTool('c1'),
-			toolResult('c1'),
-			user('again'),
-			asst('done'),
-			user('more'),
-		]
-
-		const next = await reduce(reduction(messages, { keepRecentMessages: 5 }))
-
-		const kept = new Set(next ?? [])
-		// Cutting at 3 would keep the call and its result together; cutting at
-		// 4 would orphan the result. The pair is never split either way.
-		expect(kept.has(messages[4] as Message)).toBe(kept.has(messages[3] as Message))
-	})
-
-	it('takes a cut above the requested window when nothing below is safe', async () => {
-		const reduce = createSlidingWindowReducer()
-		// A multi-step turn: the user is silent while the agent works, so every
-		// boundary inside the recent window opens on an assistant or tool
-		// message. A backwards-only search would decline here — exactly when
-		// the history is longest.
-		const messages = [
-			sys('prompt'),
-			user('go'),
-			callsTool('c1'),
-			toolResult('c1'),
-			asst('working'),
-			callsTool('c2'),
-			toolResult('c2'),
-			// The only user turn after the opening one, and it sits ABOVE the
-			// requested cut — so every candidate below opens on an assistant or
-			// tool message and the backwards search comes back empty.
-			user('next'),
-			callsTool('c3'),
-			toolResult('c3'),
-		]
-
-		const next = await reduce(reduction(messages, { keepRecentMessages: 5 }))
-
-		expect(next).toBeDefined()
-		expect(next?.length).toBeLessThan(messages.length)
-		// It kept LESS than asked rather than declining, and what it kept opens
-		// on a user turn.
-		expect(next?.[1]?.role).toBe('user')
-	})
-
-	it('keeps a pinned turn from the middle of the conversation', async () => {
-		const reduce = createSlidingWindowReducer()
-		const pinned: Message = { ...user('the account id is X'), retain: true }
-		const messages = [
-			sys('prompt'),
-			user('m0'),
-			pinned,
-			...Array.from({ length: 8 }, (_, i) => user(`m${i + 1}`)),
-		]
-
-		const next = await reduce(reduction(messages))
-
-		// Recency is not the only thing that matters, which is what `retain`
-		// exists to say.
-		expect(next).toContain(pinned)
-		expect(next).not.toContain(messages[1])
-	})
-})
-
-describe('refusing beats a reduction that would break the next turn', () => {
-	it('declines when there is nothing but the system floor to cut', async () => {
-		const reduce = createSlidingWindowReducer()
-
-		expect(await reduce(reduction([sys('prompt'), user('go')]))).toBeUndefined()
-	})
-
-	it('declines when every candidate cut splits one assistant fan-out', async () => {
-		const reduce = createSlidingWindowReducer()
-		// Six results answering one call: no cut inside the block is safe, and
-		// the condition clears itself on the next assistant message.
-		const messages = [
-			sys('prompt'),
-			user('go'),
-			{
-				role: 'assistant',
-				content: null,
-				timestamp: 1,
-				toolCalls: Array.from({ length: 6 }, (_, i) => ({
-					id: `c${i}`,
-					type: 'function' as const,
-					function: { name: 'echo', arguments: '{}' },
-				})),
-			} as AssistantMessage,
-			...Array.from({ length: 6 }, (_, i) => toolResult(`c${i}`)),
-		]
-
-		expect(await reduce(reduction(messages, { keepRecentMessages: 2 }))).toBeUndefined()
-	})
-
-	it('declines rather than reporting a reduction that removed nothing', async () => {
-		const reduce = createSlidingWindowReducer()
-		// Every non-system message is pinned, so the survivor set is the input.
-		const messages = [
-			sys('prompt'),
-			...Array.from({ length: 8 }, (_, i) => ({ ...user(`m${i}`), retain: true })),
-		]
-
-		// Saying "reduced" here would have the overflow path retry an identical
-		// prompt and burn a model call to be told the same thing.
-		expect(await reduce(reduction(messages))).toBeUndefined()
-	})
-})
-
-describe('the knob a caller reaches for', () => {
-	it('lets an explicit window override the run config', async () => {
-		const reduce = createSlidingWindowReducer({ keepRecentMessages: 2 })
-		const messages = [sys('prompt'), ...Array.from({ length: 10 }, (_, i) => user(`m${i}`))]
-
-		const next = await reduce(reduction(messages, { keepRecentMessages: 8 }))
-
-		expect(next?.length).toBe(3)
-	})
-
-	it('is a plain function, so a host can wrap one', async () => {
-		const inner = createSlidingWindowReducer()
-		const seen = vi.fn()
-		const reduce = async (input: ContextReduction) => {
-			seen(input.reason)
-			return inner(input)
-		}
-		const messages = [sys('prompt'), ...Array.from({ length: 8 }, (_, i) => user(`m${i}`))]
-
-		await reduce(reduction(messages, { reason: 'overflow' }))
-
-		expect(seen).toHaveBeenCalledWith('overflow')
-	})
-})

package/src/compaction/__tests__/context-window.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-	DEFAULT_ASSUMED_CONTEXT_WINDOW,
-	lookupContextWindow,
-	resolveContextWindow,
-} from '../context-window.js'
-
-/**
- * The compaction trigger divides "how full is the context" by a window.
- * It used to divide by `runConfig.tokenBudget` — a cumulative spend cap,
- * a different quantity entirely — which is why the whole subsystem was
- * inert in every shipped consumer.
- */
-
-describe('lookupContextWindow', () => {
-	it('resolves dated model ids through their family prefix', () => {
-		expect(lookupContextWindow('claude-opus-5-20260514')).toBe(200_000)
-		expect(lookupContextWindow('claude-sonnet-5')).toBe(200_000)
-	})
-
-	it('resolves namespaced ids from Bedrock and OpenRouter', () => {
-		expect(lookupContextWindow('us.anthropic.claude-sonnet-5-v1:0')).toBe(200_000)
-		expect(lookupContextWindow('anthropic/claude-opus-5')).toBe(200_000)
-	})
-
-	it('is case-insensitive', () => {
-		expect(lookupContextWindow('GPT-4O')).toBe(128_000)
-	})
-
-	it('prefers the more specific key when two prefixes both match', () => {
-		// 'gpt-4' also matches 'gpt-4.1' and 'gpt-4o' as a substring; the
-		// longest key must win or every GPT-4 family model collapses to 8k.
-		expect(lookupContextWindow('gpt-4.1')).toBe(1_047_576)
-		expect(lookupContextWindow('gpt-4o-mini')).toBe(128_000)
-		expect(lookupContextWindow('gpt-4')).toBe(8_192)
-	})
-
-	it('returns undefined for an unknown model rather than guessing', () => {
-		expect(lookupContextWindow('some-local-finetune-v3')).toBeUndefined()
-		expect(lookupContextWindow(undefined)).toBeUndefined()
-	})
-})
-
-describe('resolveContextWindow', () => {
-	it('an explicit config value wins over the table', () => {
-		expect(resolveContextWindow(50_000, 'claude-opus-5')).toEqual({
-			tokens: 50_000,
-			source: 'config',
-		})
-	})
-
-	it('falls back to the model table', () => {
-		expect(resolveContextWindow(undefined, 'claude-opus-5')).toEqual({
-			tokens: 200_000,
-			source: 'model-table',
-		})
-	})
-
-	it('falls back to a conservative default for an unknown model', () => {
-		expect(resolveContextWindow(undefined, 'mystery-model')).toEqual({
-			tokens: DEFAULT_ASSUMED_CONTEXT_WINDOW,
-			source: 'default',
-		})
-	})
-
-	it('ignores a zero or negative configured window instead of dividing by it', () => {
-		expect(resolveContextWindow(0, 'claude-opus-5').source).toBe('model-table')
-		expect(resolveContextWindow(-1, 'claude-opus-5').source).toBe('model-table')
-	})
-
-	it('never returns zero — the trigger divides by this', () => {
-		for (const model of [undefined, '', 'unknown', 'claude-opus-5', 'gpt-4']) {
-			expect(resolveContextWindow(undefined, model).tokens).toBeGreaterThan(0)
-		}
-	})
-})