@namzu/sdk 14.0.7 → 15.1.0

package/src/runtime/query/iteration/phases/hitl-abort-race.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { HITLResumeDecision } from '../../../../types/hitl/index.js'
-import type { RunId } from '../../../../types/ids/index.js'
-import { type IterationContext, awaitDecisionOrAbort } from './context.js'
-
-/**
- * C12: a Stop that arrives while the run is parked on a HITL decision must
- * interrupt the park (resolve as `abort`) instead of hanging until the host
- * eventually answers. `awaitDecisionOrAbort` races `resumeHandler` against
- * `ctx.abortController.signal`.
- */
-
-function ctxWith(opts: {
-	controller?: AbortController
-	resumeHandler: IterationContext['resumeHandler']
-}): IterationContext {
-	return {
-		abortController: opts.controller,
-		resumeHandler: opts.resumeHandler,
-		runMgr: { id: 'run_abort_test' as RunId },
-	} as unknown as IterationContext
-}
-
-const REVIEW_REQUEST = {
-	type: 'tool_review' as const,
-	runId: 'run_abort_test' as RunId,
-	checkpointId: 'cp_1' as `cp_${string}`,
-	toolCalls: [],
-}
-
-describe('awaitDecisionOrAbort (C12 — cancellable HITL park)', () => {
-	it('returns abort immediately when the signal is already aborted', async () => {
-		const controller = new AbortController()
-		controller.abort()
-		const ctx = ctxWith({
-			controller,
-			// A handler that never resolves — proving we did not wait on it.
-			resumeHandler: () => new Promise<HITLResumeDecision>(() => {}),
-		})
-		const decision = await awaitDecisionOrAbort(ctx, REVIEW_REQUEST)
-		expect(decision.action).toBe('abort')
-	})
-
-	it('resolves as abort when the signal fires DURING the park', async () => {
-		const controller = new AbortController()
-		const ctx = ctxWith({
-			controller,
-			resumeHandler: () => new Promise<HITLResumeDecision>(() => {}), // never answers
-		})
-		const pending = awaitDecisionOrAbort(ctx, REVIEW_REQUEST)
-		controller.abort()
-		const decision = await pending
-		expect(decision.action).toBe('abort')
-	})
-
-	it('returns the real decision when the handler answers before any abort', async () => {
-		const controller = new AbortController()
-		const ctx = ctxWith({
-			controller,
-			resumeHandler: async () => ({ action: 'approve_tools' }) as HITLResumeDecision,
-		})
-		const decision = await awaitDecisionOrAbort(ctx, REVIEW_REQUEST)
-		expect(decision.action).toBe('approve_tools')
-	})
-
-	it('degrades to a direct resumeHandler await when no controller is wired', async () => {
-		const ctx = ctxWith({
-			resumeHandler: async () => ({ action: 'reject_tools' }) as HITLResumeDecision,
-		})
-		const decision = await awaitDecisionOrAbort(ctx, REVIEW_REQUEST)
-		expect(decision.action).toBe('reject_tools')
-	})
-
-	it('fails closed to abort when the resume handler rejects', async () => {
-		const controller = new AbortController()
-		const ctx = ctxWith({
-			controller,
-			resumeHandler: async () => {
-				throw new Error('handler boom')
-			},
-		})
-		const decision = await awaitDecisionOrAbort(ctx, REVIEW_REQUEST)
-		expect(decision.action).toBe('abort')
-	})
-})

package/src/runtime/query/iteration/phases/hitl-answer-question.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { type HITLResumeDecision, autoApproveHandler } from '../../../../types/hitl/index.js'
-import type { CheckpointId, RunId } from '../../../../types/ids/index.js'
-import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
-import type { RunEvent } from '../../../../types/run/index.js'
-import { type IterationContext, handleHITLDecision } from './context.js'
-import { runToolReview } from './tool-review.js'
-
-async function drainGenerator<TReturn>(
-	gen: AsyncGenerator<RunEvent, TReturn>,
-): Promise<{ events: RunEvent[]; value: TReturn }> {
-	const events: RunEvent[] = []
-	let next = await gen.next()
-	while (!next.done) {
-		events.push(next.value)
-		next = await gen.next()
-	}
-	return { events, value: next.value }
-}
-
-describe('autoApproveHandler user_question case', () => {
-	it('returns the non-fabricating no-answer sentinel with the questionId echoed', async () => {
-		const decision = await autoApproveHandler({
-			type: 'user_question',
-			runId: 'run_headless_test' as RunId,
-			checkpointId: 'cp_question_toolu_1' as CheckpointId,
-			question: {
-				questionId: 'toolu_1',
-				question: 'Pick one?',
-				options: [
-					{ id: 'opt_1', label: 'A' },
-					{ id: 'opt_2', label: 'B' },
-				],
-				multiSelect: false,
-				allowFreeText: true,
-			},
-		})
-
-		expect(decision).toEqual({
-			action: 'answer_question',
-			selectedOptionIds: [],
-			freeText: 'No user is available to answer. Proceed using your best judgment.',
-			questionId: 'toolu_1',
-		})
-	})
-})
-
-describe('handleHITLDecision answer_question case', () => {
-	it("treats a misdirected 'answer_question' at an iteration checkpoint as continue", async () => {
-		// The branch returns without touching the context — answers are
-		// consumed inside the ask_user_question tool's own park, so an
-		// answer arriving here can only be misdirected.
-		const ctx = {} as IterationContext
-		const { events, value } = await drainGenerator(
-			handleHITLDecision(
-				ctx,
-				{ action: 'answer_question', selectedOptionIds: ['opt_1'] },
-				'cp_checkpoint_1',
-				'iteration checkpoint',
-			),
-		)
-		expect(value).toBe('continue')
-		expect(events).toEqual([])
-	})
-})
-
-describe('runToolReview answer_question case', () => {
-	function reviewContext(decision: HITLResumeDecision) {
-		const warns: string[] = []
-		const pushed: unknown[] = []
-		let batches = 0
-		const ctx = {
-			tools: { get: () => undefined },
-			checkpointMgr: {
-				create: async () => ({ id: 'cp_review_1' as CheckpointId }),
-			},
-			emitEvent: async () => {},
-			drainPending: (): Generator<RunEvent> => [][Symbol.iterator]() as Generator<RunEvent>,
-			resumeHandler: async () => decision,
-			log: {
-				debug: () => {},
-				info: () => {},
-				warn: (message: string) => {
-					warns.push(message)
-				},
-				error: () => {},
-			},
-			runMgr: {
-				id: 'run_tool_review_test' as RunId,
-				pushMessage: (message: unknown) => {
-					pushed.push(message)
-				},
-			},
-			toolExecutor: {
-				executeBatch: async () => {
-					batches += 1
-					return { messages: [], results: [] }
-				},
-			},
-		} as unknown as IterationContext
-		return { ctx, warns, pushed, batchCount: () => batches }
-	}
-
-	const response: ChatCompletionResponse = {
-		id: 'resp_1',
-		model: 'test-model',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{
-					id: 'toolu_review_1',
-					type: 'function',
-					function: { name: 'ask_user_question', arguments: '{}' },
-				},
-			],
-		},
-		finishReason: 'tool_calls',
-		usage: {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		},
-	}
-
-	it("warns and executes the batch on a misdirected 'answer_question' instead of stalling", async () => {
-		const { ctx, warns, batchCount } = reviewContext({
-			action: 'answer_question',
-			selectedOptionIds: [],
-		})
-		const { value } = await drainGenerator(runToolReview(ctx, response, 1))
-		// The review now returns its tool outcomes alongside the decision, so
-		// the loop can build a StepResult without re-deriving them.
-		expect(value.decision).toBe('executed')
-		expect(batchCount()).toBe(1)
-		expect(warns).toHaveLength(1)
-	})
-})

package/src/runtime/query/iteration/phases/overflow-escalation.test.ts

@@ -1,167 +0,0 @@
-/**
- * A forced compaction pass runs because the PROVIDER rejected the prompt
- * as too long. Two things let it decline to do anything about that:
- *
- *   1. After clearing stale tool results it re-applied the chars/4
- *      estimate — the very estimate the provider had just refuted — and
- *      returned early if that said the context was fine. So relief could
- *      report success after clearing one short result, and the retry
- *      overflowed again.
- *   2. Relief reported success on ANY positive shed. A one-character shed
- *      counted, and the retry burned a whole model call to be told the
- *      same thing.
- */
-
-import { describe, expect, it, vi } from 'vitest'
-
-import { WorkingStateManager } from '../../../../compaction/manager.js'
-import { CompactionConfigSchema } from '../../../../config/runtime.js'
-import type { RunId } from '../../../../types/ids/index.js'
-import {
-	type Message,
-	createAssistantMessage,
-	createSystemMessage,
-	createToolMessage,
-	createUserMessage,
-} from '../../../../types/message/index.js'
-import type { Logger } from '../../../../utils/logger.js'
-import { relieveOverflow } from './compaction.js'
-import type { IterationContext } from './context.js'
-
-function makeLogger(): Logger {
-	const self = {
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		debug: vi.fn(),
-	} as unknown as Logger
-	;(self as { child: (ctx: unknown) => Logger }).child = vi.fn(() => self)
-	return self
-}
-
-const bulk = (chars: number) => 'x'.repeat(chars)
-
-function makeCtx(messages: Message[]): { ctx: IterationContext; log: Logger } {
-	const config = CompactionConfigSchema.parse({
-		strategy: 'structured',
-		llmVerification: false,
-		// Large on purpose: the estimate must read as COMFORTABLE, which is
-		// exactly the state in which the provider still rejected the prompt.
-		// That is the case the early return used to mishandle.
-		contextWindowTokens: 1_000_000,
-	})
-	const manager = new WorkingStateManager(config)
-	manager.addDecision('kept going')
-	const log = makeLogger()
-
-	const ctx = {
-		runConfig: { tokenBudget: 0 },
-		compactionConfig: config,
-		workingStateManager: manager,
-		log,
-		tools: { toLLMTools: () => [] },
-		runMgr: {
-			id: 'run_1' as RunId,
-			currentIteration: 6,
-			messages,
-			lastPromptTokens: undefined,
-			lastPromptMessageCount: undefined,
-			clearLastPromptTokens: () => {},
-			accumulateUsage: () => {},
-		},
-		emitEvent: async () => {},
-	} as unknown as IterationContext
-
-	return { ctx, log }
-}
-
-/** A history with plenty of older turns and one huge stale tool result. */
-function overflowingHistory(): Message[] {
-	const messages: Message[] = [createSystemMessage('system floor')]
-	for (let i = 0; i < 8; i++) {
-		messages.push(createUserMessage(`turn ${i} ${bulk(400)}`))
-		messages.push({
-			...createAssistantMessage(''),
-			toolCalls: [
-				{ id: `t${i}`, type: 'function' as const, function: { name: 'read', arguments: '{}' } },
-			],
-		} as Message)
-		messages.push(createToolMessage(bulk(i === 0 ? 60_000 : 800), `t${i}`))
-	}
-	return messages
-}
-
-describe('a forced pass on a context the estimate thinks is fine', () => {
-	it('does not stop after clearing one tool result', async () => {
-		const messages = overflowingHistory()
-		const { ctx } = makeCtx(messages)
-		const before = messages.length
-
-		await relieveOverflow(ctx)
-
-		// The estimate said the context was comfortable — the provider had
-		// just said otherwise. Compaction, not the estimate, gets to decide
-		// whether a forced pass is done.
-		expect(ctx.runMgr.messages.length).toBeLessThan(before)
-	})
-
-	it('reports relief when it actually shed something substantial', async () => {
-		const { ctx } = makeCtx(overflowingHistory())
-		expect(await relieveOverflow(ctx)).toBe(true)
-	})
-})
-
-describe('what counts as relief', () => {
-	it('refuses when there is nothing at all to shed', async () => {
-		const { ctx, log } = makeCtx([
-			createSystemMessage('system floor'),
-			createUserMessage(bulk(200)),
-		])
-
-		expect(await relieveOverflow(ctx)).toBe(false)
-		expect(
-			(log.warn as unknown as { mock: { calls: unknown[][] } }).mock.calls.some(([message]) =>
-				String(message).includes('irreducible'),
-			),
-		).toBe(true)
-	})
-
-	it('refuses a POSITIVE shed too small to change the provider verdict', async () => {
-		// Many short turns: a forced pass genuinely sheds something, but
-		// only a few hundred characters — nowhere near enough to move a
-		// prompt the provider has already rejected. Any positive shed used
-		// to count, so the caller retried and burned a whole model call to
-		// be told the same thing.
-		const messages: Message[] = [createSystemMessage('floor')]
-		for (let i = 0; i < 14; i++) {
-			messages.push(createUserMessage(`u${i} ${bulk(30)}`))
-			messages.push(createAssistantMessage(`a${i} ${bulk(30)}`))
-		}
-		const before = messages.reduce(
-			(sum, m) => sum + (typeof m.content === 'string' ? m.content.length : 0),
-			0,
-		)
-
-		const { ctx } = makeCtx(messages)
-		const relieved = await relieveOverflow(ctx)
-
-		const after = ctx.runMgr.messages.reduce(
-			(sum, m) => sum + (typeof m.content === 'string' ? m.content.length : 0),
-			0,
-		)
-		const shed = before - after
-		// The premise of the case: something WAS shed, just not enough.
-		expect(shed).toBeGreaterThan(0)
-		expect(shed).toBeLessThan(2_000)
-		expect(relieved).toBe(false)
-	})
-
-	it('says how much it shed and how much was needed', async () => {
-		const { ctx, log } = makeCtx([createSystemMessage('floor'), createUserMessage(bulk(200))])
-		await relieveOverflow(ctx)
-
-		const warned = (log.warn as unknown as { mock: { calls: unknown[][] } }).mock.calls[0]
-		expect(warned?.[1]).toMatchObject({ charsShed: expect.any(Number) })
-		expect((warned?.[1] as { neededAtLeast: number }).neededAtLeast).toBeGreaterThan(0)
-	})
-})

package/src/runtime/query/iteration/phases/retained-messages.test.ts

@@ -1,226 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { findDanglingMessages } from '../../../../compaction/dangling.js'
-import { WorkingStateManager } from '../../../../compaction/manager.js'
-import { clearStaleToolResults } from '../../../../compaction/tool-result-editing.js'
-import { CompactionConfigSchema } from '../../../../config/runtime.js'
-import type { RunId } from '../../../../types/ids/index.js'
-import {
-	type Message,
-	createAssistantMessage,
-	createSystemMessage,
-	createToolMessage,
-	createUserMessage,
-} from '../../../../types/message/index.js'
-import type { Logger } from '../../../../utils/logger.js'
-import { runCompactionCheck } from './compaction.js'
-import type { IterationContext } from './context.js'
-
-/**
- * Everything the run protected from compaction was protected by POSITION:
- * the leading system run, the working-memory slot, the last N turns, the
- * most recent tool results. So a standing constraint stated in the MIDDLE
- * of a conversation aged out at the same rate as chatter, and no
- * positional rule could express it.
- */
-
-function makeLogger(): Logger {
-	const self = {
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		debug: vi.fn(),
-	} as unknown as Logger
-	;(self as { child: (ctx: unknown) => Logger }).child = vi.fn(() => self)
-	return self
-}
-
-const FILLER = 'x'.repeat(200)
-const CONSTRAINT = 'the account id is 4471; never bill a different one'
-
-function makeCtx(messages: Message[]): IterationContext {
-	const config = CompactionConfigSchema.parse({
-		strategy: 'structured',
-		llmVerification: false,
-		contextWindowTokens: 100,
-		// Off, so these cases exercise the rebuild rather than being
-		// satisfied by the cheap in-place reclaim that runs first.
-		clearToolResults: false,
-	})
-	const manager = new WorkingStateManager(config)
-	manager.addDecision('built the report')
-
-	return {
-		runConfig: { tokenBudget: 0 },
-		compactionConfig: config,
-		workingStateManager: manager,
-		log: makeLogger(),
-		runMgr: {
-			id: 'run_1' as RunId,
-			currentIteration: 3,
-			messages,
-			lastPromptTokens: undefined,
-			clearLastPromptTokens: () => {},
-			accumulateUsage: () => {},
-		},
-		emitEvent: async () => {},
-	} as unknown as IterationContext
-}
-
-/** A long run whose middle holds one message worth keeping. */
-function longRun(pin: (m: Message) => Message = (m) => m): Message[] {
-	const msgs: Message[] = [createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache')]
-	for (let i = 0; i < 8; i++) {
-		msgs.push(
-			i === 1 ? pin(createUserMessage(CONSTRAINT)) : createUserMessage(`user turn ${i} ${FILLER}`),
-		)
-		msgs.push(createAssistantMessage(`assistant turn ${i} ${FILLER}`))
-	}
-	return msgs
-}
-
-const pinned = (m: Message): Message => ({ ...m, retain: true })
-const asText = (content: unknown): string => (typeof content === 'string' ? content : '')
-
-describe('a message the host marked as never-evictable', () => {
-	it('is evicted without the marker', async () => {
-		// The premise. Without this the next case proves nothing: the
-		// message might simply have been recent enough to survive.
-		const messages = longRun()
-		await runCompactionCheck(makeCtx(messages))
-
-		expect(messages.some((m) => asText(m.content) === CONSTRAINT)).toBe(false)
-	})
-
-	it('survives the pass verbatim', async () => {
-		const messages = longRun(pinned)
-		await runCompactionCheck(makeCtx(messages))
-
-		expect(messages.some((m) => asText(m.content).includes('[COMPACTED CONTEXT]'))).toBe(true)
-		expect(messages.some((m) => asText(m.content) === CONSTRAINT)).toBe(true)
-	})
-
-	it('sits after the summary and before the recent window', async () => {
-		const messages = longRun(pinned)
-		await runCompactionCheck(makeCtx(messages))
-
-		const summary = messages.findIndex((m) => asText(m.content).includes('[COMPACTED CONTEXT]'))
-		const kept = messages.findIndex((m) => asText(m.content) === CONSTRAINT)
-		const lastTurn = messages.findIndex((m) => asText(m.content).startsWith('assistant turn 7'))
-
-		expect(kept).toBeGreaterThan(summary)
-		expect(kept).toBeLessThan(lastTurn)
-	})
-
-	it('does not keep the run alive by pinning everything', async () => {
-		// The marker is a budget the setter spends, and the pass must still
-		// reclaim what was not pinned.
-		const messages = longRun(pinned)
-		const before = messages.length
-		await runCompactionCheck(makeCtx(messages))
-
-		expect(messages.length).toBeLessThan(before)
-	})
-})
-
-describe('a pinned half of a tool pair', () => {
-	function runWithPairs(pinIndex: 'call' | 'result'): Message[] {
-		const call = {
-			id: 'call_pinned',
-			type: 'function' as const,
-			function: { name: 'lookup_account', arguments: '{}' },
-		}
-		const msgs: Message[] = [createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache')]
-		msgs.push(createUserMessage(`user turn 0 ${FILLER}`))
-		const assistant = { ...createAssistantMessage(null, [call]) } as Message
-		const result = createToolMessage(CONSTRAINT, 'call_pinned') as Message
-		msgs.push(
-			pinIndex === 'call' ? { ...assistant, retain: true } : assistant,
-			pinIndex === 'result' ? { ...result, retain: true } : result,
-		)
-		for (let i = 1; i < 8; i++) {
-			msgs.push(createUserMessage(`user turn ${i} ${FILLER}`))
-			msgs.push(createAssistantMessage(`assistant turn ${i} ${FILLER}`))
-		}
-		return msgs
-	}
-
-	it('pulls in the result when the call is pinned', async () => {
-		const messages = runWithPairs('call')
-		await runCompactionCheck(makeCtx(messages))
-
-		// Half a pair is not a smaller history — a `tool_use` with no
-		// `tool_result` is rejected outright on the next turn.
-		expect(findDanglingMessages(messages).isValid).toBe(true)
-		expect(messages.some((m) => asText(m.content) === CONSTRAINT)).toBe(true)
-	})
-
-	it('pulls in the call when the result is pinned', async () => {
-		const messages = runWithPairs('result')
-		await runCompactionCheck(makeCtx(messages))
-
-		expect(findDanglingMessages(messages).isValid).toBe(true)
-		expect(messages.some((m) => m.role === 'assistant' && m.toolCalls?.length)).toBe(true)
-	})
-
-	it('pulls in the SIBLING results of a fan-out, not just the pinned one', async () => {
-		// The second hop. Pinning one result pulls in its assistant turn,
-		// and that turn issued two more calls — an assistant with three
-		// calls and one surviving result is the same dangling error in the
-		// other direction.
-		const calls = ['a', 'b', 'c'].map((suffix) => ({
-			id: `call_${suffix}`,
-			type: 'function' as const,
-			function: { name: `lookup_${suffix}`, arguments: '{}' },
-		}))
-		const messages: Message[] = [createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache')]
-		messages.push(createUserMessage(`user turn 0 ${FILLER}`))
-		messages.push(createAssistantMessage(null, calls) as Message)
-		messages.push(
-			{ ...(createToolMessage(CONSTRAINT, 'call_a') as Message), retain: true },
-			createToolMessage(`sibling b ${FILLER}`, 'call_b') as Message,
-			createToolMessage(`sibling c ${FILLER}`, 'call_c') as Message,
-		)
-		for (let i = 1; i < 8; i++) {
-			messages.push(createUserMessage(`user turn ${i} ${FILLER}`))
-			messages.push(createAssistantMessage(`assistant turn ${i} ${FILLER}`))
-		}
-
-		await runCompactionCheck(makeCtx(messages))
-
-		expect(findDanglingMessages(messages).isValid).toBe(true)
-		expect(messages.filter((m) => m.role === 'tool')).toHaveLength(3)
-	})
-})
-
-describe('a pinned tool result and the cheap in-place reclaim', () => {
-	function bigResults(pin: boolean): Message[] {
-		const calls = [0, 1, 2, 3].map((i) => ({
-			id: `call_${i}`,
-			type: 'function' as const,
-			function: { name: 'lookup_account', arguments: '{}' },
-		}))
-		const msgs: Message[] = [createUserMessage('go')]
-		for (const call of calls) {
-			msgs.push(createAssistantMessage(null, [call]) as Message)
-			const body = `${CONSTRAINT} ${'y'.repeat(5000)}`
-			const result = createToolMessage(body, call.id) as Message
-			msgs.push(pin && call.id === 'call_0' ? { ...result, retain: true } : result)
-		}
-		return msgs
-	}
-
-	it('is cleared without the marker', async () => {
-		const edit = clearStaleToolResults(bigResults(false), { keepRecentToolResults: 1 })
-		expect(edit.clearedCount).toBe(3)
-	})
-
-	it('keeps its content when marked', async () => {
-		// Clearing keeps the message and replaces its content, which is
-		// exactly the loss the marker was asked to prevent.
-		const edit = clearStaleToolResults(bigResults(true), { keepRecentToolResults: 1 })
-
-		expect(edit.clearedCount).toBe(2)
-		expect(asText(edit.messages[2]?.content)).toContain(CONSTRAINT)
-	})
-})