@namzu/sdk 14.0.7 → 15.1.0

package/src/runtime/query/__tests__/durable-question-park.test.ts

@@ -1,305 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { buildCoordinatorTools } from '../../../tools/coordinator/index.js'
-import type {
-	CheckpointId,
-	HITLResumeDecision,
-	IterationCheckpoint,
-} from '../../../types/hitl/index.js'
-import type { RunId } from '../../../types/ids/index.js'
-import { createAssistantMessage, createUserMessage } from '../../../types/message/index.js'
-import type { Message } from '../../../types/message/index.js'
-import type { Logger } from '../../../utils/logger.js'
-import { PendingAnswers, QuestionParkBinding } from '../question-park.js'
-import { planPendingResume } from '../resume-pending.js'
-
-/**
- * `ask_user_question` parked through the raw handler under a synthetic
- * `cp_question_<toolUseId>` id that was never written. The checkpoint
- * therefore did not exist: nothing on disk said a human owed this run an
- * answer, and a remote host could not even OBSERVE the question except
- * through the in-process callback.
- *
- * Kill the process while somebody is looking at the card and the answer
- * could never be applied — the restore path stripped the whole assistant
- * turn, discarding work sibling tools in the same batch had finished and
- * re-billing the turn.
- *
- * The re-entry half is the one that was deferred: on resume the batch is
- * re-executed, which is HOW the asking tool is re-entered, and the
- * recorded answer is handed to it instead of a second question.
- */
-
-const RID = 'run_1' as RunId
-
-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 QUESTION_INPUT = {
-	question: 'Which environment?',
-	options: [
-		{ label: 'Staging', description: 'safe' },
-		{ label: 'Production', description: 'not safe' },
-	],
-	multiSelect: false,
-	allowFreeText: true,
-}
-
-function askTool(opts: {
-	resumeHandler: (request: unknown) => Promise<HITLResumeDecision>
-	questionParks?: QuestionParkBinding
-	pendingAnswers?: PendingAnswers
-}) {
-	const tools = buildCoordinatorTools({
-		gateway: {} as never,
-		workingDirectory: '/tmp',
-		allowedAgentIds: [],
-		runId: RID,
-		resumeHandler: opts.resumeHandler as never,
-		...(opts.questionParks ? { questionParks: opts.questionParks } : {}),
-		...(opts.pendingAnswers ? { pendingAnswers: opts.pendingAnswers } : {}),
-	})
-	const tool = tools.find((t) => t.name === 'ask_user_question')
-	if (!tool) throw new Error('ask_user_question was not built')
-	return tool
-}
-
-const answer = (questionId: string): HITLResumeDecision => ({
-	action: 'answer_question',
-	selectedOptionIds: ['opt_1'],
-	questionId,
-})
-
-describe('recording the park', () => {
-	it('writes a real checkpoint and hands the tool its id', async () => {
-		const recorded: string[] = []
-		const parks = new QuestionParkBinding()
-		parks.bind({
-			record: async (q) => {
-				recorded.push(q.questionId)
-				return 'cp_real' as CheckpointId
-			},
-			resolve: async () => {},
-		})
-
-		let seenCheckpointId: string | undefined
-		const tool = askTool({
-			questionParks: parks,
-			resumeHandler: async (request) => {
-				seenCheckpointId = (request as { checkpointId: string }).checkpointId
-				return answer('t1')
-			},
-		})
-
-		await tool.execute(QUESTION_INPUT as never, { toolUseId: 't1' } as never)
-
-		expect(recorded).toEqual(['t1'])
-		// The synthetic id was never written anywhere, so a host given it
-		// could not read the checkpoint back.
-		expect(seenCheckpointId).toBe('cp_real')
-	})
-
-	it('clears the park once the answer arrives', async () => {
-		const resolved: string[] = []
-		const parks = new QuestionParkBinding()
-		parks.bind({
-			record: async () => 'cp_real' as CheckpointId,
-			resolve: async (id) => {
-				resolved.push(id)
-			},
-		})
-
-		const tool = askTool({ questionParks: parks, resumeHandler: async () => answer('t1') })
-		await tool.execute(QUESTION_INPUT as never, { toolUseId: 't1' } as never)
-
-		// An approval queue that keeps serving an answered question is the
-		// same defect the tool-review park already fixed.
-		expect(resolved).toEqual(['cp_real'])
-	})
-
-	it('still asks when the park cannot be recorded', async () => {
-		// An unrecorded park is a lost cross-process handoff, not a reason
-		// to fail the tool — the in-process await is still perfectly valid.
-		const parks = new QuestionParkBinding()
-		parks.bind({ record: async () => null, resolve: async () => {} })
-
-		const tool = askTool({ questionParks: parks, resumeHandler: async () => answer('t1') })
-		const result = await tool.execute(QUESTION_INPUT as never, { toolUseId: 't1' } as never)
-
-		expect(result.success).toBe(true)
-	})
-
-	it('is inert when nothing has bound it', async () => {
-		// The tool outlives the run that binds it, so an unbound channel is
-		// the normal state outside a run — and must behave exactly as it
-		// did before any of this existed.
-		const parks = new QuestionParkBinding()
-		expect(await parks.record({ questionId: 't1' } as never)).toBeNull()
-		await expect(parks.resolve('cp_x' as CheckpointId, answer('t1'))).resolves.toBeUndefined()
-	})
-
-	it('stops writing into a run that has settled', async () => {
-		const parks = new QuestionParkBinding()
-		parks.bind({ record: async () => 'cp_real' as CheckpointId, resolve: async () => {} })
-		parks.unbind()
-
-		expect(await parks.record({ questionId: 't1' } as never)).toBeNull()
-	})
-})
-
-describe('re-entering the tool with the answer', () => {
-	it('returns the carried answer without asking again', async () => {
-		const handler = vi.fn(async () => answer('t1'))
-		const pending = new PendingAnswers()
-		pending.set('t1', answer('t1'))
-
-		const tool = askTool({ pendingAnswers: pending, resumeHandler: handler })
-		const result = await tool.execute(QUESTION_INPUT as never, { toolUseId: 't1' } as never)
-
-		// Asking again would put a question the user already answered back
-		// in front of them — and headless, would auto-answer with the
-		// no-consent sentinel and throw the real answer away.
-		expect(handler).not.toHaveBeenCalled()
-		expect(result.success).toBe(true)
-		expect(String(result.output)).toContain('Staging')
-	})
-
-	it('does not record a park for a question it already has an answer to', async () => {
-		const recorded: string[] = []
-		const parks = new QuestionParkBinding()
-		parks.bind({
-			record: async (q) => {
-				recorded.push(q.questionId)
-				return 'cp_real' as CheckpointId
-			},
-			resolve: async () => {},
-		})
-		const pending = new PendingAnswers()
-		pending.set('t1', answer('t1'))
-
-		const tool = askTool({
-			questionParks: parks,
-			pendingAnswers: pending,
-			resumeHandler: async () => answer('t1'),
-		})
-		await tool.execute(QUESTION_INPUT as never, { toolUseId: 't1' } as never)
-
-		// Parking an answered question leaves an outstanding record for a
-		// decision that has been made.
-		expect(recorded).toEqual([])
-	})
-
-	it('consumes an answer once', async () => {
-		// A tool that asks the same question twice in one resumed run is
-		// asking something genuinely new the second time; answering it from
-		// a stale record would fabricate consent.
-		const pending = new PendingAnswers()
-		pending.set('t1', answer('t1'))
-
-		expect(pending.take('t1')).toBeDefined()
-		expect(pending.take('t1')).toBeUndefined()
-	})
-
-	it('falls through to a real ask for a question it has no answer to', async () => {
-		const handler = vi.fn(async () => answer('t2'))
-		const pending = new PendingAnswers()
-		pending.set('t1', answer('t1'))
-
-		const tool = askTool({ pendingAnswers: pending, resumeHandler: handler })
-		await tool.execute(QUESTION_INPUT as never, { toolUseId: 't2' } as never)
-
-		expect(handler).toHaveBeenCalledTimes(1)
-	})
-
-	it('carries only an answer that names its question', async () => {
-		// The misdirection guard: a decision with no questionId cannot be
-		// matched to a call, so it must not be delivered to whichever tool
-		// happens to run next.
-		const unaddressed = PendingAnswers.from({
-			action: 'answer_question',
-			selectedOptionIds: ['opt_1'],
-		})
-		expect(unaddressed.size).toBe(0)
-
-		const approval = PendingAnswers.from({ action: 'approve_tools' })
-		expect(approval.size).toBe(0)
-	})
-})
-
-describe('planning the resume', () => {
-	const parkedTurn = (): Message[] => [
-		createUserMessage('deploy it'),
-		{
-			...createAssistantMessage(''),
-			toolCalls: [
-				{
-					id: 't1',
-					type: 'function' as const,
-					function: { name: 'ask_user_question', arguments: '{}' },
-				},
-				{ id: 't2', type: 'function' as const, function: { name: 'read', arguments: '{}' } },
-			],
-		} as Message,
-	]
-
-	const checkpoint = (questionId: string, messages = parkedTurn()): IterationCheckpoint =>
-		({
-			id: 'cp_1' as CheckpointId,
-			messages,
-			pending: {
-				parkedAt: 0,
-				request: {
-					type: 'user_question',
-					runId: RID,
-					checkpointId: 'cp_1' as CheckpointId,
-					question: {
-						questionId,
-						question: 'Which?',
-						options: [],
-						multiSelect: false,
-						allowFreeText: true,
-					},
-				},
-			},
-		}) as unknown as IterationCheckpoint
-
-	it('takes over a question park instead of declining it', async () => {
-		// This used to return null with "out of scope", so the restore path
-		// stripped the turn and the answer was lost.
-		const plan = planPendingResume(checkpoint('t1'), answer('t1'), makeLogger())
-
-		expect(plan).not.toBeNull()
-		// The whole batch is re-executed — that is how the asking tool gets
-		// re-entered at all.
-		expect(plan?.response.message.toolCalls).toHaveLength(2)
-	})
-
-	it('carries the answer for the call that asked', async () => {
-		const plan = planPendingResume(checkpoint('t1'), answer('t1'), makeLogger())
-		expect(plan?.answers?.take('t1')).toBeDefined()
-	})
-
-	it('denies nothing — a question is not an approval gate', async () => {
-		const plan = planPendingResume(checkpoint('t1'), answer('t1'), makeLogger())
-		expect(plan?.denials.size).toBe(0)
-	})
-
-	it('refuses an answer to a question not in this turn', async () => {
-		// A stale client answering an earlier question would otherwise have
-		// its answer delivered to whatever tool now holds that slot.
-		const plan = planPendingResume(checkpoint('t9'), answer('t9'), makeLogger())
-		expect(plan).toBeNull()
-	})
-
-	it('refuses a checkpoint whose turn is already answered', async () => {
-		const answered: Message[] = [
-			...parkedTurn(),
-			{ role: 'tool', content: 'staging', toolCallId: 't1' } as Message,
-			{ role: 'tool', content: 'read', toolCallId: 't2' } as Message,
-		]
-		expect(planPendingResume(checkpoint('t1', answered), answer('t1'), makeLogger())).toBeNull()
-	})
-})

package/src/runtime/query/__tests__/durable-run-state.test.ts

@@ -1,194 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { DiskCheckpointStore } from '../../../store/run/checkpoint-disk.js'
-import type {
-	CheckpointId,
-	HITLDecisionRequest,
-	IterationCheckpoint,
-} from '../../../types/hitl/index.js'
-import type { RunId, SessionId, TenantId } from '../../../types/ids/index.js'
-import type { CheckpointRunScope } from '../../../types/run/checkpoint-store.js'
-import { RUN_STATE_VERSION, RunStateVersionError, parseRunState } from '../../../types/run/state.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { ZERO_COST } from '../../../utils/cost.js'
-import { CheckpointManager, findPendingCheckpoint } from '../checkpoint.js'
-import { type RunStateScope, loadRunState } from '../run-state.js'
-
-/**
- * A parked approval used to exist only as a suspended `await` inside one
- * process. Nothing on disk said a human owed the run an answer, so an
- * approval queue could not be rebuilt and a serverless host could not park
- * a run at all — the container that held the promise had to stay alive.
- */
-
-const RUN_ID = 'run_durable' as RunId
-let baseDir: string
-let store: DiskCheckpointStore
-let scope: RunStateScope
-
-beforeEach(async () => {
-	baseDir = await mkdtemp(join(tmpdir(), 'namzu-durable-'))
-	store = new DiskCheckpointStore({ baseDir })
-	scope = {
-		tenantId: 'tnt_d' as TenantId,
-		projectId: 'prj_d' as ProjectId,
-		sessionId: 'ses_d' as SessionId,
-		threadId: 'thd_d' as ThreadId,
-		runId: RUN_ID,
-	}
-})
-
-afterEach(async () => {
-	await rm(baseDir, { recursive: true, force: true })
-})
-
-function checkpoint(id: string, iteration: number): IterationCheckpoint {
-	return {
-		id: id as CheckpointId,
-		runId: RUN_ID,
-		iteration,
-		messages: [{ role: 'user', content: `turn ${iteration}` }],
-		tokenUsage: {
-			promptTokens: 10 * iteration,
-			completionTokens: iteration,
-			totalTokens: 11 * iteration,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		},
-		costInfo: { ...ZERO_COST },
-		guardState: { iterationCount: iteration, elapsedMs: 1_000 * iteration },
-		createdAt: 1_700_000_000_000 + iteration,
-	}
-}
-
-const reviewRequest = (checkpointId: string): HITLDecisionRequest => ({
-	type: 'tool_review',
-	runId: RUN_ID,
-	checkpointId: checkpointId as CheckpointId,
-	toolCalls: [{ id: 'call_1', name: 'delete_row', input: { id: 42 }, isDestructive: true }],
-})
-
-describe('recording a park', () => {
-	it('makes the outstanding decision readable from the store alone', async () => {
-		const mgr = new CheckpointManager(store, scope as CheckpointRunScope)
-		const cp = checkpoint('cp_1', 1)
-		await store.writeCheckpoint(scope, cp)
-
-		expect(await findPendingCheckpoint(store, scope)).toBeNull()
-
-		await mgr.park(cp, reviewRequest('cp_1'))
-
-		// A DIFFERENT reader — a fresh store over the same directory, i.e.
-		// what a second process has.
-		const fresh = new DiskCheckpointStore({ baseDir })
-		const found = await findPendingCheckpoint(fresh, scope)
-		expect(found?.id).toBe('cp_1')
-		expect(found?.pending?.request.type).toBe('tool_review')
-		expect(found?.pending?.parkedAt).toBeGreaterThan(0)
-	})
-
-	it('stops being outstanding once answered, and keeps the answer as evidence', async () => {
-		const mgr = new CheckpointManager(store, scope as CheckpointRunScope)
-		const cp = checkpoint('cp_1', 1)
-		await store.writeCheckpoint(scope, cp)
-		await mgr.park(cp, reviewRequest('cp_1'))
-
-		await mgr.unpark('cp_1' as CheckpointId, { action: 'approve_tools' })
-
-		expect(await findPendingCheckpoint(store, scope)).toBeNull()
-		const stored = await store.readCheckpoint(scope, 'cp_1' as CheckpointId)
-		// Not erased — a gate that cannot say what was approved is not an
-		// audit trail.
-		expect(stored?.pending?.decision).toEqual({ action: 'approve_tools' })
-		expect(stored?.pending?.resolvedAt).toBeGreaterThan(0)
-	})
-
-	it('returns the newest outstanding park when several checkpoints exist', async () => {
-		const mgr = new CheckpointManager(store, scope as CheckpointRunScope)
-		for (const [id, n] of [
-			['cp_1', 1],
-			['cp_2', 2],
-			['cp_3', 3],
-		] as const) {
-			await store.writeCheckpoint(scope, checkpoint(id, n))
-		}
-		await mgr.park(checkpoint('cp_1', 1), reviewRequest('cp_1'))
-		await mgr.unpark('cp_1' as CheckpointId, { action: 'approve_tools' })
-		await mgr.park(checkpoint('cp_3', 3), reviewRequest('cp_3'))
-
-		expect((await findPendingCheckpoint(store, scope))?.id).toBe('cp_3')
-	})
-
-	it('unparking something that was never parked is a no-op, not a crash', async () => {
-		const mgr = new CheckpointManager(store, scope as CheckpointRunScope)
-		await store.writeCheckpoint(scope, checkpoint('cp_1', 1))
-		expect(await mgr.unpark('cp_1' as CheckpointId, { action: 'approve_tools' })).toBeNull()
-		expect(await mgr.unpark('cp_gone' as CheckpointId, { action: 'approve_tools' })).toBeNull()
-	})
-})
-
-describe('loadRunState', () => {
-	it('rebuilds a snapshot with no live run object', async () => {
-		await store.writeCheckpoint(scope, checkpoint('cp_1', 1))
-		await store.writeCheckpoint(scope, checkpoint('cp_2', 2))
-
-		const state = await loadRunState(store, scope)
-
-		expect(state).not.toBeNull()
-		expect(state?.runId).toBe(RUN_ID)
-		expect(state?.currentIteration).toBe(2)
-		// Budgets are properties of the RUN, not of the process hosting it.
-		expect(state?.elapsedMs).toBe(2_000)
-		expect(state?.tokenUsage.totalTokens).toBe(22)
-		expect(state?.checkpointId).toBe('cp_2')
-	})
-
-	it('prefers the outstanding park over the newest checkpoint', async () => {
-		// "What is this run waiting on" is the question a resuming process
-		// is actually asking.
-		const mgr = new CheckpointManager(store, scope as CheckpointRunScope)
-		await store.writeCheckpoint(scope, checkpoint('cp_1', 1))
-		await store.writeCheckpoint(scope, checkpoint('cp_2', 2))
-		await mgr.park(checkpoint('cp_1', 1), reviewRequest('cp_1'))
-
-		const state = await loadRunState(store, scope)
-		expect(state?.checkpointId).toBe('cp_1')
-		expect(state?.pending?.request.type).toBe('tool_review')
-	})
-
-	it('returns null for a run that never checkpointed', async () => {
-		// Rather than synthesizing a snapshot that would restart from zero
-		// while claiming to be a continuation.
-		expect(await loadRunState(store, scope)).toBeNull()
-	})
-
-	it('survives a JSON round trip', async () => {
-		await store.writeCheckpoint(scope, checkpoint('cp_1', 1))
-		const state = await loadRunState(store, scope)
-		const revived = parseRunState(JSON.stringify(state))
-		expect(revived).toEqual(state)
-	})
-})
-
-describe('parseRunState', () => {
-	it('refuses a snapshot from an incompatible version', () => {
-		// A silent partial restore produces a run that looks healthy and has
-		// lost its budgets.
-		expect(() => parseRunState(JSON.stringify({ version: 99, runId: RUN_ID }))).toThrow(
-			RunStateVersionError,
-		)
-	})
-
-	it('refuses a snapshot with no version at all', () => {
-		expect(() => parseRunState('{"runId":"run_x"}')).toThrow(RunStateVersionError)
-		expect(() => parseRunState('null')).toThrow(RunStateVersionError)
-	})
-
-	it('accepts an object as well as a string', () => {
-		const state = { version: RUN_STATE_VERSION, runId: RUN_ID }
-		expect(parseRunState(state).runId).toBe(RUN_ID)
-	})
-})

package/src/runtime/query/__tests__/effort-reaches-the-wire.test.ts

@@ -1,135 +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 { createUserMessage } from '../../../types/message/index.js'
-import type { AgentRunConfig } from '../../../types/run/index.js'
-import { drainQuery } from '../index.js'
-
-/**
- * `effort` was declared on the provider params, exported, and read by a driver
- * that wrote it straight to the wire — and nothing in the kernel ever set it.
- * No caller could reach it, and the symptom (every request going out at the
- * model's default) reads as "this model ignores effort" rather than "nobody
- * plumbed it through".
- *
- * These drive a real run and read what the provider was actually handed, which
- * is the only thing that distinguishes a wired field from a declared one. A
- * test asserting the field exists on the config type would have passed against
- * the broken version.
- */
-
-let workdirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-async function run(overrides: Partial<AgentRunConfig>, turns: unknown[]): Promise<MockLLMProvider> {
-	const provider = new MockLLMProvider({ turns: turns as never })
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-effort-'))
-	workdirs.push(dir)
-
-	await drainQuery({
-		provider,
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 2,
-			...overrides,
-		},
-		agentId: 'agent_effort',
-		agentName: 'Effort Agent',
-		workingDirectory: dir,
-		sessionId: 'ses_effort',
-		threadId: 'thd_effort',
-		projectId: 'prj_effort',
-		tenantId: 'tnt_effort',
-		messages: [createUserMessage('go')],
-	} as never)
-
-	return provider
-}
-
-describe('an effort level set on the run reaches the provider', () => {
-	it('arrives on the request', async () => {
-		const provider = await run({ effort: 'max' }, [{ text: 'done' }])
-
-		expect(provider.requests.length).toBeGreaterThan(0)
-		expect(provider.requests[0]?.effort).toBe('max')
-	})
-
-	it('is absent when nobody asked for one', async () => {
-		// Not `undefined`-valued but genuinely absent: a present key carrying
-		// undefined is the kind of thing that survives a spread into a request
-		// body and reaches a wire that did not expect the field.
-		const provider = await run({}, [{ text: 'done' }])
-
-		expect(provider.requests[0] && 'effort' in provider.requests[0]).toBe(false)
-	})
-
-	it('rides every turn of the run, not only the first', async () => {
-		// The value is run-level because the provider documents that changing
-		// it between requests invalidates the cached prefix. A run that
-		// forwarded it once and then stopped would pay that cost silently.
-		const provider = await run({ effort: 'low' }, [{ text: 'one' }, { text: 'two' }])
-
-		for (const request of provider.requests) {
-			expect(request.effort).toBe('low')
-		}
-	})
-
-	it('travels alongside thinking rather than inside it', async () => {
-		const provider = await run({ effort: 'high', thinking: { type: 'adaptive' } }, [
-			{ text: 'done' },
-		])
-
-		expect(provider.requests[0]?.effort).toBe('high')
-		expect(provider.requests[0]?.thinking?.type).toBe('adaptive')
-	})
-})
-
-describe('the front door forwards it too, not only the kernel', () => {
-	/**
-	 * These exist because everything above passed while a real run put NOTHING
-	 * on the wire.
-	 *
-	 * `drainQuery` takes the run config a caller hands it, so testing through
-	 * it proves the loop forwards the field and nothing about whether a caller
-	 * can set it. Every ergonomic entry point — this one, `ReactiveAgent`,
-	 * `SupervisorAgent`, and the manager's bare-config branch — builds its
-	 * `AgentRunConfig` by HAND-LISTING fields, so a field nobody remembered to
-	 * add is dropped in silence, with no cast to blame and no error to see.
-	 * `thinking` had been in that state since it shipped.
-	 *
-	 * It was found by watching an actual HTTP body, which is the only place the
-	 * gap is visible. So the regression test drives the front door.
-	 */
-	it('reaches the provider through runAgent', async () => {
-		const { runAgent } = await import('../../../agents/runAgent.js')
-		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] as never })
-		const dir = await mkdtemp(join(tmpdir(), 'namzu-effort-door-'))
-		workdirs.push(dir)
-
-		await runAgent({
-			provider,
-			model: 'mock-model',
-			prompt: 'go',
-			workingDirectory: dir,
-			effort: 'xhigh',
-			thinking: { type: 'adaptive' },
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 2,
-		})
-
-		expect(provider.requests.length).toBeGreaterThan(0)
-		expect(provider.requests[0]?.effort, 'the front door dropped effort').toBe('xhigh')
-		expect(provider.requests[0]?.thinking?.type, 'the front door dropped thinking').toBe('adaptive')
-	})
-})