@namzu/sdk 14.0.7 → 15.0.0

package/src/runtime/query/iteration/phases/tool-review-denials.test.ts

@@ -1,270 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { findDanglingMessages } from '../../../../compaction/dangling.js'
-import { ActivityStore } from '../../../../store/activity/memory.js'
-import type { HITLResumeDecision } from '../../../../types/hitl/index.js'
-import type { RunId } from '../../../../types/ids/index.js'
-import type { Message } from '../../../../types/message/index.js'
-import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
-import type { ToolRegistryContract } from '../../../../types/tool/index.js'
-import type { VerificationGateConfig } from '../../../../types/verification/index.js'
-import type { Logger } from '../../../../utils/logger.js'
-import { VerificationGate } from '../../../../verification/gate.js'
-import { ToolExecutor } from '../../executor.js'
-import type { IterationContext } from './context.js'
-import { runToolReview } from './tool-review.js'
-
-/**
- * Regression suite for the tool-review invariant:
- *
- *   Every `tool_use` block the model emits is answered by exactly one
- *   `tool_result`, on every path — gate denial, human rejection, partial
- *   approval — because an unanswered `tool_use` makes the NEXT provider
- *   request malformed and kills the run.
- *
- * Plus the policy invariant discovered alongside it: a human "approve" on
- * the gate's mixed-decision path must not execute the calls the gate
- * denied.
- */
-
-const RUN_ID = 'run_denial_test' as RunId
-
-function makeLogger(): Logger {
-	const stub = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
-	return { ...stub, child: vi.fn(() => ({ ...stub, child: vi.fn() })) } as unknown as Logger
-}
-
-/** `read` is read-only (gate-allowable); `bash rm -rf /` trips deny_dangerous_patterns. */
-function response(): ChatCompletionResponse {
-	return {
-		id: 'resp_1',
-		model: 'test',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [
-				{
-					id: 'call_safe',
-					type: 'function',
-					function: { name: 'read', arguments: JSON.stringify({ path: 'a.txt' }) },
-				},
-				{
-					id: 'call_danger',
-					type: 'function',
-					function: { name: 'bash', arguments: JSON.stringify({ command: 'rm -rf /' }) },
-				},
-			],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-interface Harness {
-	ctx: IterationContext
-	messages: Message[]
-	executed: string[]
-}
-
-/** The schema fills defaults; tests only state the rules they care about. */
-function gateConfig(partial: Partial<VerificationGateConfig>): VerificationGateConfig {
-	return {
-		enabled: true,
-		rules: [],
-		allowReadOnlyTools: false,
-		denyDangerousPatterns: false,
-		logDecisions: false,
-		...partial,
-	}
-}
-
-function harness(opts: {
-	gate?: VerificationGateConfig
-	decision?: HITLResumeDecision
-}): Harness {
-	const executed: string[] = []
-	const messages: Message[] = []
-	const log = makeLogger()
-
-	const toolDefs: Record<string, { readOnly: boolean; category: string }> = {
-		read: { readOnly: true, category: 'filesystem' },
-		bash: { readOnly: false, category: 'shell' },
-	}
-
-	const tools = {
-		get: vi.fn((name: string) => {
-			const def = toolDefs[name]
-			if (!def) return undefined
-			return {
-				name,
-				category: def.category,
-				isReadOnly: () => def.readOnly,
-				isDestructive: () => !def.readOnly,
-				isConcurrencySafe: () => def.readOnly,
-			}
-		}),
-		execute: vi.fn(async (name: string) => {
-			executed.push(name)
-			return { success: true, output: `${name} ok` }
-		}),
-		has: vi.fn(() => true),
-		listNames: vi.fn(() => Object.keys(toolDefs)),
-		getAvailability: vi.fn(() => 'active'),
-		register: vi.fn(),
-		unregister: vi.fn(),
-	} as unknown as ToolRegistryContract
-
-	const toolExecutor = new ToolExecutor(
-		{
-			tools,
-			runId: RUN_ID,
-			workingDirectory: '/tmp',
-			permissionMode: 'auto',
-			env: {},
-			abortSignal: new AbortController().signal,
-		},
-		new ActivityStore(RUN_ID, { enabled: true, trackToolCalls: true, trackLlmTurns: true }),
-		async () => {},
-		log,
-	)
-
-	const ctx = {
-		tools,
-		toolExecutor,
-		log,
-		abortController: new AbortController(),
-		runMgr: {
-			id: RUN_ID,
-			messages,
-			pushMessage: (m: Message) => {
-				messages.push(m)
-			},
-			setStopReason: vi.fn(),
-			markCancelled: vi.fn(),
-		},
-		checkpointMgr: { create: async () => ({ id: 'cp_1' }) },
-		emitEvent: async () => {},
-		drainPending: async function* () {},
-		resumeHandler: async () => opts.decision ?? ({ action: 'approve_tools' } as HITLResumeDecision),
-		verificationGate: opts.gate ? new VerificationGate(opts.gate, log) : undefined,
-	} as unknown as IterationContext
-
-	return { ctx, messages, executed }
-}
-
-/** Drain the generator and return its decision. */
-async function run(ctx: IterationContext, resp: ChatCompletionResponse) {
-	const gen = runToolReview(ctx, resp, 1)
-	let next = await gen.next()
-	while (!next.done) next = await gen.next()
-	return next.value.decision
-}
-
-/** The whole point: history must be sendable to a provider afterwards. */
-function expectEveryToolCallAnswered(messages: Message[], resp: ChatCompletionResponse) {
-	const assistant: Message = {
-		role: 'assistant',
-		content: resp.message.content,
-		toolCalls: resp.message.toolCalls,
-	}
-	const history = [assistant, ...messages]
-	const dangling = findDanglingMessages(history)
-	expect(dangling.assistantsWithUnmatchedCalls).toEqual([])
-	expect(dangling.orphanedToolMessages).toEqual([])
-	expect(dangling.isValid).toBe(true)
-
-	const answered = messages
-		.filter((m): m is Message & { toolCallId: string } => m.role === 'tool')
-		.map((m) => m.toolCallId)
-	expect(answered.sort()).toEqual((resp.message.toolCalls ?? []).map((tc) => tc.id).sort())
-}
-
-describe('runToolReview — every tool_use is answered', () => {
-	it('gate all-deny still emits a tool_result per call', async () => {
-		const h = harness({
-			gate: gateConfig({ rules: [{ type: 'deny_by_name', toolNames: ['read', 'bash'] }] }),
-		})
-		const resp = response()
-		const outcome = await run(h.ctx, resp)
-
-		expect(outcome).toBe('rejected')
-		expect(h.executed).toEqual([])
-		expectEveryToolCallAnswered(h.messages, resp)
-		// The reason must travel inside the tool_result so it can steer.
-		expect(h.messages.some((m) => String(m.content).includes('verification gate'))).toBe(true)
-	})
-
-	it('human reject_tools still emits a tool_result per call, carrying the feedback', async () => {
-		const h = harness({
-			decision: { action: 'reject_tools', feedback: 'Use the API instead of shelling out.' },
-		})
-		const resp = response()
-		const outcome = await run(h.ctx, resp)
-
-		expect(outcome).toBe('rejected')
-		expect(h.executed).toEqual([])
-		expectEveryToolCallAnswered(h.messages, resp)
-		expect(h.messages.some((m) => String(m.content).includes('Use the API instead'))).toBe(true)
-	})
-
-	it('modify_tools with a PARTIAL deny answers the denied call too', async () => {
-		const h = harness({
-			decision: {
-				action: 'modify_tools',
-				modifications: [{ toolCallId: 'call_danger', action: 'deny' }],
-			} as HITLResumeDecision,
-		})
-		const resp = response()
-		const outcome = await run(h.ctx, resp)
-
-		expect(outcome).toBe('executed')
-		expect(h.executed).toEqual(['read'])
-		expectEveryToolCallAnswered(h.messages, resp)
-	})
-
-	it('plain approval executes everything and answers everything', async () => {
-		const h = harness({ decision: { action: 'approve_tools' } })
-		const resp = response()
-		const outcome = await run(h.ctx, resp)
-
-		expect(outcome).toBe('executed')
-		expect(h.executed.sort()).toEqual(['bash', 'read'])
-		expectEveryToolCallAnswered(h.messages, resp)
-	})
-})
-
-describe('runToolReview — a gate denial outranks a human approval', () => {
-	it('approve_tools on the gate MIXED path does not execute the gate-denied call', async () => {
-		// allow_read_only allows `read`; deny_dangerous_patterns denies the
-		// `rm -rf /` bash call → mixed → human review → human approves.
-		const h = harness({
-			gate: gateConfig({ allowReadOnlyTools: true, denyDangerousPatterns: true }),
-			decision: { action: 'approve_tools' },
-		})
-		const resp = response()
-		const outcome = await run(h.ctx, resp)
-
-		expect(outcome).toBe('executed')
-		// THE BUG: this used to be ['read', 'bash'] — approval replayed the
-		// full unfiltered response and ran the call the gate refused.
-		expect(h.executed).toEqual(['read'])
-		expectEveryToolCallAnswered(h.messages, resp)
-	})
-
-	it('modify_tools cannot rewrite a gate-denied call back into execution', async () => {
-		const h = harness({
-			gate: gateConfig({ allowReadOnlyTools: true, denyDangerousPatterns: true }),
-			decision: {
-				action: 'modify_tools',
-				modifications: [
-					{ toolCallId: 'call_danger', action: 'modify', modifiedInput: { command: 'ls' } },
-				],
-			} as HITLResumeDecision,
-		})
-		const resp = response()
-		await run(h.ctx, resp)
-
-		expect(h.executed).toEqual(['read'])
-		expectEveryToolCallAnswered(h.messages, resp)
-	})
-})

package/src/runtime/query/iteration/phases/working-memory-compaction.test.ts

@@ -1,227 +0,0 @@
-/**
- * Regression test for the ses_055 Layer-B SDK seam (#104):
- *
- *   1. **Compaction FIRES** under a small `contextWindowTokens` even with the
- *      run-level `tokenBudget = 0` (UNLIMITED) — proving the F1 fix repointed
- *      BOTH the `<= 0` guard AND the divisor, closing the silent-no-op trap.
- *   2. **The pinned working-memory slot SURVIVES** the compaction pass (it is a
- *      leading system message → preserved by header identity).
- *   3. **No premature stop** from `tokenBudget = 0` alone: with NO
- *      `contextWindowTokens`, the same overflowing run does NOT compact (the
- *      legacy fallback), so consumers that never set the new field are
- *      byte-identical.
- *
- * The test drives `refreshWorkingMemory` (to pin the slot) then
- * `runCompactionCheck` directly against a mock `IterationContext`, which is the
- * exact sequence the iteration loop runs each turn.
- */
-
-import { describe, expect, it, vi } from 'vitest'
-
-import { findDanglingMessages } from '../../../../compaction/dangling.js'
-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 { runCompactionCheck } from './compaction.js'
-import type { IterationContext } from './context.js'
-import { WORKING_MEMORY_HEADER, refreshWorkingMemory } from './working-memory.js'
-
-function makeLogger(): Logger {
-	const self = {
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		debug: vi.fn(),
-		child: vi.fn(),
-	} as unknown as Logger
-	;(self as { child: (ctx: unknown) => Logger }).child = vi.fn(() => self)
-	return self
-}
-
-/** A long string so a handful of messages overflow a small context window. */
-const FILLER = 'x'.repeat(200)
-
-function buildOverflowingMessages(): Message[] {
-	const msgs: Message[] = [createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache')]
-	for (let i = 0; i < 8; i++) {
-		msgs.push(createUserMessage(`user turn ${i} ${FILLER}`))
-		msgs.push(createAssistantMessage(`assistant turn ${i} ${FILLER}`))
-	}
-	return msgs
-}
-
-function makeCtx(opts: {
-	messages: Message[]
-	contextWindowTokens?: number
-	workingMemoryProvider?: IterationContext['workingMemoryProvider']
-}): IterationContext {
-	const config = CompactionConfigSchema.parse({
-		strategy: 'structured',
-		llmVerification: false,
-		...(opts.contextWindowTokens !== undefined
-			? { contextWindowTokens: opts.contextWindowTokens }
-			: {}),
-	})
-	const manager = new WorkingStateManager(config)
-	// Seed a couple of slots so serializeState produces non-trivial output.
-	manager.addDecision('built the report as .docx')
-
-	return {
-		runConfig: { tokenBudget: 0 }, // UNLIMITED cumulative cost cap
-		compactionConfig: config,
-		workingStateManager: manager,
-		workingMemoryProvider: opts.workingMemoryProvider,
-		log: makeLogger(),
-		runMgr: {
-			id: 'run_1' as RunId,
-			currentIteration: 3,
-			messages: opts.messages,
-			// Compaction prefers the provider's reported prompt size over the
-			// chars/4 heuristic; `undefined` keeps these cases on the estimate
-			// path they were written against.
-			lastPromptTokens: undefined,
-			clearLastPromptTokens: () => {},
-			accumulateUsage: () => {},
-		},
-		emitEvent: async () => {},
-	} as unknown as IterationContext
-}
-
-const WM_BLOCK =
-	'ARTIFACTS\n  • report.docx · Word document · 48.2 KB · imp:H\n       path: /mnt/user-data/outputs/report.docx'
-
-/** Messages can now carry content blocks; these cases are about text. */
-function asText(content: unknown): string {
-	return typeof content === 'string' ? content : ''
-}
-
-describe('Layer-B compaction seam (ses_055 #104)', () => {
-	it('FIRES on small contextWindowTokens with tokenBudget=0 AND preserves the pinned WM slot', async () => {
-		const messages = buildOverflowingMessages()
-		const ctx = makeCtx({
-			messages,
-			contextWindowTokens: 100,
-			workingMemoryProvider: () => WM_BLOCK,
-		})
-
-		await refreshWorkingMemory(ctx)
-		// The slot is pinned as the last leading system message (index 1).
-		expect(messages[1]?.role).toBe('system')
-		expect(asText(messages[1]?.content).startsWith(WORKING_MEMORY_HEADER)).toBe(true)
-
-		const before = messages.length
-		await runCompactionCheck(ctx)
-
-		// (1) compaction fired: a [COMPACTED CONTEXT] message appeared and the
-		// transcript shrank.
-		expect(messages.length).toBeLessThan(before)
-		expect(messages.some((m) => asText(m.content).includes('[COMPACTED CONTEXT]'))).toBe(true)
-
-		// (2) the pinned working-memory slot survived by header identity.
-		const wm = messages.filter(
-			(m) => m.role === 'system' && asText(m.content).startsWith(WORKING_MEMORY_HEADER),
-		)
-		expect(wm).toHaveLength(1)
-		expect(wm[0]?.content).toContain('report.docx')
-	})
-
-	it('does NOT compact when contextWindowTokens is absent and tokenBudget=0 (byte-identical fallback)', async () => {
-		const messages = buildOverflowingMessages()
-		const ctx = makeCtx({ messages })
-
-		const before = messages.length
-		await runCompactionCheck(ctx)
-
-		// budget = tokenBudget = 0 → guard returns; no compaction, no mutation.
-		expect(messages.length).toBe(before)
-		expect(messages.some((m) => asText(m.content).includes('[COMPACTED CONTEXT]'))).toBe(false)
-	})
-
-	it('removes the slot when the provider returns an empty block', async () => {
-		const messages = buildOverflowingMessages()
-		const ctx = makeCtx({
-			messages,
-			contextWindowTokens: 100,
-			workingMemoryProvider: () => WM_BLOCK,
-		})
-		await refreshWorkingMemory(ctx)
-		expect(messages.some((m) => asText(m.content).startsWith(WORKING_MEMORY_HEADER))).toBe(true)
-
-		// Same transcript, provider now returns blank ⇒ the slot is removed.
-		const blankCtx = makeCtx({
-			messages,
-			contextWindowTokens: 100,
-			workingMemoryProvider: () => '   ',
-		})
-		await refreshWorkingMemory(blankCtx)
-		expect(messages.some((m) => asText(m.content).startsWith(WORKING_MEMORY_HEADER))).toBe(false)
-	})
-
-	it('keeps the prior slot when the provider throws (failure-isolated)', async () => {
-		const messages = buildOverflowingMessages()
-		const ctx = makeCtx({
-			messages,
-			contextWindowTokens: 100,
-			workingMemoryProvider: () => WM_BLOCK,
-		})
-		await refreshWorkingMemory(ctx)
-
-		const throwingCtx = makeCtx({
-			messages,
-			contextWindowTokens: 100,
-			workingMemoryProvider: () => {
-				throw new Error('provider boom')
-			},
-		})
-		await refreshWorkingMemory(throwingCtx)
-		// Prior slot retained; run not broken.
-		expect(messages.some((m) => asText(m.content).startsWith(WORKING_MEMORY_HEADER))).toBe(true)
-	})
-
-	it('does NOT orphan a tool_result when the recent-window cut splits a tool pair (C1)', async () => {
-		// keepRecentMessages defaults to 4. Lay the transcript out so the NAIVE
-		// cut (length - 4 = index 5) lands right AFTER the assistant-with-toolCall
-		// (index 4) but BEFORE... no — exactly ON its tool result (index 5), which
-		// a naive slice would keep in the recent window while dropping the
-		// assistant into the summarized older set → an orphaned tool_result at the
-		// head of the recent window → a 400 from the wire. The fix snaps keepStart
-		// forward past the complete pair.
-		const toolCall = {
-			id: 't1',
-			type: 'function' as const,
-			function: { name: 'read', arguments: '{}' },
-		}
-		const messages: Message[] = [
-			createSystemMessage(`STATIC SYSTEM PROMPT ${FILLER}`, 'cache'),
-			createUserMessage(`user 0 ${FILLER}`),
-			createAssistantMessage(`assistant 0 ${FILLER}`),
-			createUserMessage(`user 1 ${FILLER}`),
-			createAssistantMessage(`calling a tool ${FILLER}`, [toolCall]), // idx 4
-			createToolMessage(`tool result ${FILLER}`, 't1'), // idx 5 — naive recent[0]
-			createAssistantMessage(`assistant 2 ${FILLER}`),
-			createUserMessage(`user 3 ${FILLER}`),
-			createAssistantMessage(`assistant 3 ${FILLER}`),
-		]
-		const ctx = makeCtx({ messages, contextWindowTokens: 100 })
-
-		await runCompactionCheck(ctx)
-
-		// Compaction fired.
-		expect(messages.some((m) => asText(m.content).includes('[COMPACTED CONTEXT]'))).toBe(true)
-		// The surviving transcript has NO dangling tool pair — the tool result
-		// whose assistant was summarized away was moved into the older set too,
-		// so no orphaned tool_result remains to 400 the next provider turn.
-		expect(findDanglingMessages(messages).isValid).toBe(true)
-		// And a `tool` message never leads the recent window.
-		const firstNonSystem = messages.find((m) => m.role !== 'system')
-		expect(firstNonSystem?.role).not.toBe('tool')
-	})
-})

package/src/runtime/query/replay/__tests__/mutate.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { ToolCallId } from '../../../../types/ids/index.js'
-import type { AssistantMessage, Message, ToolMessage } from '../../../../types/message/index.js'
-import { type Mutation, MutationNotApplicableError } from '../../../../types/run/replay.js'
-import { applyMutations } from '../mutate.js'
-
-function assistantWithCalls(toolCallIds: string[]): AssistantMessage {
-	return {
-		role: 'assistant',
-		content: null,
-		toolCalls: toolCallIds.map((id) => ({
-			id,
-			type: 'function',
-			function: { name: 'noop', arguments: '{}' },
-		})),
-	}
-}
-
-describe('applyMutations / injectToolResponse', () => {
-	it('appends a ToolMessage when the toolCallId is pending', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'do stuff' },
-			assistantWithCalls(['call_a', 'call_b']),
-			{ role: 'tool', content: 'a done', toolCallId: 'call_a' },
-		]
-		const mutations: Mutation[] = [
-			{
-				type: 'injectToolResponse',
-				toolCallId: 'call_b' as ToolCallId,
-				response: { success: true, output: 'mocked-b', data: { x: 1 } },
-			},
-		]
-
-		const result = applyMutations(messages, mutations)
-
-		expect(result).toHaveLength(4)
-		const last = result[3] as ToolMessage
-		expect(last.role).toBe('tool')
-		expect(last.toolCallId).toBe('call_b')
-		expect(last.content).toBe('mocked-b')
-	})
-
-	it('throws MutationNotApplicableError when no pending tool calls exist', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'hi' },
-			{ role: 'assistant', content: 'hello' },
-		]
-		expect(() =>
-			applyMutations(messages, [
-				{
-					type: 'injectToolResponse',
-					toolCallId: 'call_missing' as ToolCallId,
-					response: { success: true, output: 'x' },
-				},
-			]),
-		).toThrow(MutationNotApplicableError)
-	})
-
-	it('throws with availableToolCallIds populated when toolCallId is not pending', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'do stuff' },
-			assistantWithCalls(['call_a', 'call_b']),
-		]
-		try {
-			applyMutations(messages, [
-				{
-					type: 'injectToolResponse',
-					toolCallId: 'call_z' as ToolCallId,
-					response: { success: true, output: 'x' },
-				},
-			])
-			expect.fail('expected MutationNotApplicableError')
-		} catch (err) {
-			expect(err).toBeInstanceOf(MutationNotApplicableError)
-			const e = err as MutationNotApplicableError
-			expect(e.availableToolCallIds).toEqual(['call_a', 'call_b'])
-		}
-	})
-
-	it('considers a tool call satisfied only when a subsequent ToolMessage responds to it', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'do stuff' },
-			assistantWithCalls(['call_a', 'call_b', 'call_c']),
-			{ role: 'tool', content: 'a done', toolCallId: 'call_a' },
-			{ role: 'tool', content: 'c done', toolCallId: 'call_c' },
-		]
-		try {
-			applyMutations(messages, [
-				{
-					type: 'injectToolResponse',
-					toolCallId: 'call_a' as ToolCallId,
-					response: { success: true, output: 're-answered' },
-				},
-			])
-			expect.fail('expected MutationNotApplicableError — call_a already satisfied')
-		} catch (err) {
-			const e = err as MutationNotApplicableError
-			expect(e.availableToolCallIds).toEqual(['call_b'])
-		}
-	})
-
-	it('applies mutations in order so a later mutation sees earlier ones', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'two calls pending' },
-			assistantWithCalls(['call_x', 'call_y']),
-		]
-		const result = applyMutations(messages, [
-			{
-				type: 'injectToolResponse',
-				toolCallId: 'call_x' as ToolCallId,
-				response: { success: true, output: 'x-result' },
-			},
-			{
-				type: 'injectToolResponse',
-				toolCallId: 'call_y' as ToolCallId,
-				response: { success: true, output: 'y-result' },
-			},
-		])
-
-		expect(result).toHaveLength(4)
-		expect((result[2] as ToolMessage).toolCallId).toBe('call_x')
-		expect((result[3] as ToolMessage).toolCallId).toBe('call_y')
-	})
-
-	it('returns the original messages unchanged when the mutation list is empty', () => {
-		const messages: Message[] = [
-			{ role: 'user', content: 'no-op' },
-			{ role: 'assistant', content: 'ok' },
-		]
-		const result = applyMutations(messages, [])
-		expect(result).toEqual(messages)
-		expect(result).not.toBe(messages)
-	})
-})