@namzu/sdk 14.0.6 → 15.0.0

package/src/runtime/query/__tests__/resume-pending.test.ts

@@ -1,273 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-
-import { MockLLMProvider } from '../../../provider/mock.js'
-import { ToolRegistry } from '../../../registry/tool/execute.js'
-import { DiskCheckpointStore } from '../../../store/run/checkpoint-disk.js'
-import type { HITLResumeDecision, ResumeHandler } from '../../../types/hitl/index.js'
-import type { RunId, SessionId, TenantId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import type { ToolDefinition } from '../../../types/tool/index.js'
-import { findPendingCheckpoint } from '../checkpoint.js'
-import { drainQuery } from '../index.js'
-import { type RunStateScope, loadRunState } from '../run-state.js'
-
-/**
- * The whole point of #14, end to end: a run parks on a tool approval in
- * ONE `query()` call, that call returns, and a SECOND `query()` — standing
- * in for a different process — honors the approval a human gave in
- * between.
- *
- * Before this, the second call repaired the unanswered `tool_use` blocks
- * away and let the model re-decide, so "yes, delete that row" degraded
- * into "ask the model again and hope it asks for the same thing".
- */
-
-const dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-async function workdir(): Promise<string> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-resume-'))
-	dirs.push(dir)
-	return dir
-}
-
-/** Records every call so a test can prove a tool did — or did not — run. */
-function deleteRowTool(calls: string[]): ToolDefinition<{ id: number }> {
-	return {
-		name: 'delete_row',
-		description: 'Delete a row',
-		inputSchema: z.object({ id: z.number() }),
-		isDestructive: () => true,
-		execute: ({ id }) => {
-			calls.push(`delete:${id}`)
-			return Promise.resolve({ success: true, output: `deleted ${id}` })
-		},
-	}
-}
-
-interface Harness {
-	dir: string
-	scope: RunStateScope
-	store: DiskCheckpointStore
-	calls: string[]
-	tools: ToolRegistry
-}
-
-async function harness(): Promise<Harness> {
-	const dir = await workdir()
-	const calls: string[] = []
-	const tools = new ToolRegistry()
-	tools.register(deleteRowTool(calls) as unknown as ToolDefinition)
-	return {
-		dir,
-		calls,
-		tools,
-		store: new DiskCheckpointStore({ baseDir: join(dir, 'runs') }),
-		scope: {
-			tenantId: 'tnt_r' as TenantId,
-			projectId: 'prj_r' as ProjectId,
-			sessionId: 'ses_r' as SessionId,
-			threadId: 'thd_r' as ThreadId,
-			runId: 'run_r' as RunId,
-		},
-	}
-}
-
-function baseParams(h: Harness, provider: MockLLMProvider, resumeHandler: ResumeHandler) {
-	return {
-		provider,
-		tools: h.tools,
-		resumeHandler,
-		checkpointStore: h.store,
-		runId: h.scope.runId,
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 10_000,
-			tokenBudget: 100_000,
-			maxIterations: 4,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_r',
-		agentName: 'Resumable',
-		workingDirectory: h.dir,
-		sessionId: h.scope.sessionId,
-		threadId: h.scope.threadId,
-		projectId: h.scope.projectId,
-		tenantId: h.scope.tenantId,
-	}
-}
-
-/** Answers the first review by pausing, which ends the run still parked. */
-const pauseOnReview: ResumeHandler = (request) =>
-	Promise.resolve(
-		request.type === 'tool_review'
-			? ({ action: 'pause', reason: 'waiting for a human' } as HITLResumeDecision)
-			: ({ action: 'continue' } as HITLResumeDecision),
-	)
-
-describe('an approval survives a process boundary', () => {
-	it('parks durably, then a second run applies the recorded decision', async () => {
-		const h = await harness()
-
-		// --- process 1: run until it parks on the destructive call ---
-		const first = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'delete_row', args: { id: 42 } }] }],
-		})
-		const parked = await drainQuery({
-			...baseParams(h, first, pauseOnReview),
-			messages: [createUserMessage('delete row 42')],
-		})
-		expect(parked.stopReason).toBe('paused')
-		expect(h.calls).toEqual([])
-
-		// --- the handoff: durable state is all process 2 gets ---
-		const state = await loadRunState(new DiskCheckpointStore({ baseDir: join(h.dir, 'runs') }), {
-			...h.scope,
-			runId: parked.id,
-		})
-		expect(state?.pending?.request.type).toBe('tool_review')
-		const recalled =
-			state?.pending?.request.type === 'tool_review' ? state.pending.request.toolCalls : []
-		expect(recalled.map((tc) => tc.name)).toEqual(['delete_row'])
-		expect(recalled[0]?.isDestructive).toBe(true)
-
-		// --- process 2: the human said yes ---
-		const second = new MockLLMProvider({ turns: [{ text: 'row 42 is gone' }] })
-		const resumed = await drainQuery({
-			...baseParams(h, second, pauseOnReview),
-			messages: [],
-			resumeFromCheckpoint: state?.checkpointId,
-			pendingDecision: { action: 'approve_tools' },
-		})
-
-		// The approved call ran — without the model being asked to re-decide.
-		expect(h.calls).toEqual(['delete:42'])
-		expect(resumed.result).toBe('row 42 is gone')
-		// And the model saw the tool result, not a repaired-away history.
-		const sent = second.requests[0]?.messages ?? []
-		expect(sent.some((m) => m.role === 'tool')).toBe(true)
-	})
-
-	it('a rejection collected out-of-band steers the model instead of executing', async () => {
-		const h = await harness()
-
-		const first = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'delete_row', args: { id: 7 } }] }],
-		})
-		const parked = await drainQuery({
-			...baseParams(h, first, pauseOnReview),
-			messages: [createUserMessage('delete row 7')],
-		})
-
-		const state = await loadRunState(h.store, { ...h.scope, runId: parked.id })
-		const second = new MockLLMProvider({ turns: [{ text: 'understood, leaving it alone' }] })
-		await drainQuery({
-			...baseParams(h, second, pauseOnReview),
-			messages: [],
-			resumeFromCheckpoint: state?.checkpointId,
-			pendingDecision: { action: 'reject_tools', feedback: 'too risky' },
-		})
-
-		expect(h.calls).toEqual([])
-		// The refusal rides inside the tool_result, which is what lets a
-		// rejection steer rather than merely stop.
-		const toolMsg = (second.requests[0]?.messages ?? []).find((m) => m.role === 'tool')
-		expect(JSON.stringify(toolMsg)).toContain('too risky')
-	})
-
-	it('ignores a decision whose tool calls no longer match — consent is not transferable', async () => {
-		const h = await harness()
-		const first = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'delete_row', args: { id: 1 } }] }],
-		})
-		const parked = await drainQuery({
-			...baseParams(h, first, pauseOnReview),
-			messages: [createUserMessage('delete row 1')],
-		})
-
-		// Tamper with the recorded request so it describes a different batch.
-		const cp = await findPendingCheckpoint(h.store, { ...h.scope, runId: parked.id })
-		if (!cp?.pending || cp.pending.request.type !== 'tool_review') throw new Error('no park')
-		await h.store.writeCheckpoint(
-			{ ...h.scope, runId: parked.id },
-			{
-				...cp,
-				pending: {
-					...cp.pending,
-					request: {
-						...cp.pending.request,
-						toolCalls: [{ ...cp.pending.request.toolCalls[0]!, id: 'call_other' }],
-					},
-				},
-			},
-		)
-
-		const second = new MockLLMProvider({ turns: [{ text: 'nothing to do' }] })
-		await drainQuery({
-			...baseParams(h, second, pauseOnReview),
-			messages: [],
-			resumeFromCheckpoint: cp.id,
-			pendingDecision: { action: 'approve_tools' },
-		})
-
-		// Falls back to repair-and-re-decide rather than executing a batch
-		// nobody approved.
-		expect(h.calls).toEqual([])
-	})
-
-	it('a decision that does not describe a batch falls back to the repair path', async () => {
-		const h = await harness()
-		const first = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'delete_row', args: { id: 3 } }] }],
-		})
-		const parked = await drainQuery({
-			...baseParams(h, first, pauseOnReview),
-			messages: [createUserMessage('delete row 3')],
-		})
-		const state = await loadRunState(h.store, { ...h.scope, runId: parked.id })
-
-		const second = new MockLLMProvider({ turns: [{ text: 'ok' }] })
-		await drainQuery({
-			...baseParams(h, second, pauseOnReview),
-			messages: [],
-			resumeFromCheckpoint: state?.checkpointId,
-			// `continue` says nothing about what to do with pending calls.
-			pendingDecision: { action: 'continue' },
-		})
-
-		expect(h.calls).toEqual([])
-	})
-})
-
-describe('park recording stays off the hot path', () => {
-	it('a handler that answers instantly never writes a park', async () => {
-		const h = await harness()
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'delete_row', args: { id: 5 } }] }, { text: 'done' }],
-		})
-		const instant = vi.fn<ResumeHandler>(() =>
-			Promise.resolve({ action: 'approve_tools' } as HITLResumeDecision),
-		)
-
-		const run = await drainQuery({
-			...baseParams(h, provider, instant),
-			messages: [createUserMessage('delete row 5')],
-		})
-
-		expect(h.calls).toEqual(['delete:5'])
-		expect(instant).toHaveBeenCalled()
-		// The iteration gate runs every iteration; recording each park
-		// unconditionally would triple a long run's checkpoint writes to
-		// describe a park that never happened.
-		expect(await findPendingCheckpoint(h.store, { ...h.scope, runId: run.id })).toBeNull()
-	})
-})

package/src/runtime/query/__tests__/resume-run.test.ts

@@ -1,262 +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 type { CheckpointId, IterationCheckpoint } from '../../../types/hitl/index.js'
-import type { RunId, SessionId, TenantId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { CheckpointRunScope, CheckpointStore } from '../../../types/run/checkpoint-store.js'
-import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
-import { resumeRun } from '../resume-run.js'
-import type { RunStateScope } from '../run-state.js'
-
-/**
- * The pieces of a cross-process resume all existed and nothing joined them.
- * `CheckpointManager` wrote the history, budgets, working state and any
- * park; `loadRunState` read them back; `query` accepted `runId` +
- * `resumeFromCheckpoint` and restored all of it. But `resumeFromCheckpoint`
- * had no caller anywhere outside `packages/sdk/src`, so the whole path
- * shipped untravelled — every host was expected to write the same wiring
- * and none did.
- *
- * These cover the join, and especially its two refusals: a resume must not
- * quietly become a fresh run under a recycled id, and it must not step past
- * a park without the answer that park is waiting for.
- */
-
-const SCOPE: RunStateScope = {
-	tenantId: 'tnt_resume' as TenantId,
-	projectId: 'prj_resume' as ProjectId,
-	sessionId: 'ses_resume' as SessionId,
-	runId: 'run_resume' as RunId,
-	threadId: 'thd_resume' as ThreadId,
-}
-
-const ZERO_USAGE = {
-	promptTokens: 0,
-	completionTokens: 0,
-	totalTokens: 0,
-	cachedTokens: 0,
-	cacheWriteTokens: 0,
-}
-
-const ZERO_COST = {
-	inputCostPer1M: 0,
-	outputCostPer1M: 0,
-	totalCost: 0,
-	cacheDiscount: 0,
-}
-
-class InMemoryCheckpointStore implements CheckpointStore {
-	readonly rows = new Map<string, IterationCheckpoint>()
-
-	private key(scope: CheckpointRunScope, id: CheckpointId): string {
-		return [scope.tenantId, scope.projectId, scope.sessionId, scope.runId, id].join('/')
-	}
-
-	async writeCheckpoint(scope: CheckpointRunScope, checkpoint: IterationCheckpoint): Promise<void> {
-		this.rows.set(this.key(scope, checkpoint.id), checkpoint)
-	}
-
-	async readCheckpoint(
-		scope: CheckpointRunScope,
-		id: CheckpointId,
-	): Promise<IterationCheckpoint | null> {
-		return this.rows.get(this.key(scope, id)) ?? null
-	}
-
-	async listCheckpoints(scope: CheckpointRunScope): Promise<IterationCheckpoint[]> {
-		const prefix = `${[scope.tenantId, scope.projectId, scope.sessionId, scope.runId].join('/')}/`
-		return [...this.rows.entries()]
-			.filter(([key]) => key.startsWith(prefix))
-			.map(([, cp]) => cp)
-			.sort((a, b) => a.createdAt - b.createdAt)
-	}
-
-	async deleteCheckpoint(scope: CheckpointRunScope, id: CheckpointId): Promise<void> {
-		this.rows.delete(this.key(scope, id))
-	}
-}
-
-function checkpoint(overrides: Partial<IterationCheckpoint> = {}): IterationCheckpoint {
-	return {
-		id: 'ckpt_1' as CheckpointId,
-		runId: SCOPE.runId,
-		iteration: 2,
-		messages: [createUserMessage('the work so far')],
-		tokenUsage: { ...ZERO_USAGE, promptTokens: 120, totalTokens: 120 },
-		costInfo: { ...ZERO_COST, totalCost: 0.4 },
-		guardState: { iterationCount: 2, elapsedMs: 9_000 },
-		createdAt: Date.now(),
-		...overrides,
-	} as IterationCheckpoint
-}
-
-let workdirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-async function mkWorkdir(): Promise<string> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-resume-run-'))
-	workdirs.push(dir)
-	return dir
-}
-
-async function baseParams(store: CheckpointStore) {
-	return {
-		scope: SCOPE,
-		checkpointStore: store,
-		provider: new MockLLMProvider({ turns: [{ text: 'continued' }] }),
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 2,
-			maxResponseTokens: 256,
-		},
-		agentId: 'agent_resume',
-		agentName: 'Resume Agent',
-		workingDirectory: await mkWorkdir(),
-		sessionId: SCOPE.sessionId,
-		threadId: SCOPE.threadId,
-		projectId: SCOPE.projectId,
-		tenantId: SCOPE.tenantId,
-		// Required by the contract, and rightly so: a resume that lands on a
-		// park has to have somewhere to ask.
-		resumeHandler: async () => ({ action: 'continue' as const }),
-	}
-}
-
-describe('a run is picked back up from its store', () => {
-	it('continues the same run id rather than starting a new one', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(SCOPE, checkpoint())
-
-		const outcome = await resumeRun(await baseParams(store))
-
-		expect(outcome.resumed).toBe(true)
-		if (!outcome.resumed) return
-		// The whole point: a resume is the same run in a different process,
-		// so its id, budgets and trace all have to carry across.
-		expect(outcome.run.id).toBe(SCOPE.runId)
-		expect(outcome.state.checkpointId).toBe('ckpt_1')
-	})
-
-	it('carries the spent budget forward instead of granting a fresh one', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(SCOPE, checkpoint())
-
-		const outcome = await resumeRun(await baseParams(store))
-
-		expect(outcome.resumed).toBe(true)
-		if (!outcome.resumed) return
-		// A run recalled at 120 tokens must not come back at zero — the
-		// budget belongs to the run, not to the process hosting it.
-		expect(outcome.run.tokenUsage.totalTokens).toBeGreaterThanOrEqual(120)
-	})
-
-	it('picks the newest checkpoint when the caller names none', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(SCOPE, checkpoint({ id: 'ckpt_old' as CheckpointId, createdAt: 1 }))
-		await store.writeCheckpoint(
-			SCOPE,
-			checkpoint({ id: 'ckpt_new' as CheckpointId, createdAt: 2_000 }),
-		)
-
-		const outcome = await resumeRun(await baseParams(store))
-
-		expect(outcome.resumed).toBe(true)
-		if (!outcome.resumed) return
-		expect(outcome.state.checkpointId).toBe('ckpt_new')
-	})
-
-	it('honours an explicitly named checkpoint', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(SCOPE, checkpoint({ id: 'ckpt_old' as CheckpointId, createdAt: 1 }))
-		await store.writeCheckpoint(
-			SCOPE,
-			checkpoint({ id: 'ckpt_new' as CheckpointId, createdAt: 2_000 }),
-		)
-
-		const outcome = await resumeRun({
-			...(await baseParams(store)),
-			checkpointId: 'ckpt_old' as CheckpointId,
-		})
-
-		expect(outcome.resumed).toBe(true)
-		if (!outcome.resumed) return
-		expect(outcome.state.checkpointId).toBe('ckpt_old')
-	})
-})
-
-describe('it refuses rather than guessing', () => {
-	it('reports no checkpoint instead of silently starting fresh', async () => {
-		const outcome = await resumeRun(await baseParams(new InMemoryCheckpointStore()))
-
-		// Starting a new run here would be the worst outcome: a different
-		// run wearing a recycled id, with the original's budget reset.
-		expect(outcome).toEqual({ resumed: false, reason: 'no-checkpoint' })
-	})
-
-	it('hands back the outstanding question instead of resuming past it', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(
-			SCOPE,
-			checkpoint({
-				pending: {
-					request: {
-						type: 'tool_review',
-						runId: SCOPE.runId,
-						checkpointId: 'ckpt_1' as CheckpointId,
-						toolCalls: [{ id: 'call_1', name: 'write', input: {} }],
-					},
-					parkedAt: Date.now(),
-					deadlineAt: Date.now() + 60_000,
-				},
-			} as unknown as Partial<IterationCheckpoint>),
-		)
-
-		const outcome = await resumeRun(await baseParams(store))
-
-		expect(outcome.resumed).toBe(false)
-		if (outcome.resumed || outcome.reason !== 'awaiting-decision') {
-			throw new Error(`expected awaiting-decision, got ${JSON.stringify(outcome)}`)
-		}
-		// The host needs the request itself to put in front of a person.
-		expect(outcome.pending.request.type).toBe('tool_review')
-		expect(outcome.state.runId).toBe(SCOPE.runId)
-	})
-
-	it('treats an already-answered park as an ordinary resume', async () => {
-		const store = new InMemoryCheckpointStore()
-		await store.writeCheckpoint(
-			SCOPE,
-			checkpoint({
-				pending: {
-					request: {
-						type: 'tool_review',
-						runId: SCOPE.runId,
-						checkpointId: 'ckpt_1' as CheckpointId,
-						toolCalls: [{ id: 'call_1', name: 'write', input: {} }],
-					},
-					parkedAt: Date.now(),
-					deadlineAt: Date.now() + 60_000,
-					resolvedAt: Date.now(),
-				},
-			} as unknown as Partial<IterationCheckpoint>),
-		)
-
-		const outcome = await resumeRun(await baseParams(store))
-
-		// `resolvedAt` is what makes a park answered. Blocking on one that
-		// already has its answer would strand the run permanently.
-		expect(outcome.resumed).toBe(true)
-	})
-})

package/src/runtime/query/__tests__/rich-content-budget-wiring.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { ActivityStore } from '../../../store/activity/memory.js'
-import type { RunId } from '../../../types/ids/index.js'
-import type { ChatCompletionResponse } from '../../../types/provider/index.js'
-import type { ToolRegistryContract, ToolResult } from '../../../types/tool/index.js'
-import type { Logger } from '../../../utils/logger.js'
-import { ToolingBootstrap } from '../tooling.js'
-
-/**
- * The rich-content budget was declared on the executor's own config and read
- * in exactly one place — and no caller could set it. `ToolingBootstrapConfig`
- * had no such field, so the value the executor read was always `undefined`,
- * the cap was always `0`, and the capping branch plus its warn were
- * unreachable. A knob documented as "a host that knows its payloads sets it"
- * could not be set by any host.
- *
- * This covers the chain, not the capping: the capping is already tested
- * against an executor built by hand, which is precisely how the gap survived.
- */
-
-const RUN_ID = 'run_budget' 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
-}
-
-function response(): ChatCompletionResponse {
-	return {
-		id: 'r',
-		model: 'm',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [{ id: 'call_1', type: 'function', function: { name: 'shot', arguments: '{}' } }],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-function bootstrapReturning(result: ToolResult, maxToolContentBytes?: number) {
-	const tools = {
-		get: vi.fn(() => ({
-			name: 'shot',
-			isConcurrencySafe: () => true,
-			isReadOnly: () => true,
-			isDestructive: () => false,
-		})),
-		execute: vi.fn(async () => result),
-		has: vi.fn(() => true),
-		listNames: vi.fn(() => []),
-		getAvailability: vi.fn(() => 'active'),
-		register: vi.fn(),
-		unregister: vi.fn(),
-	} as unknown as ToolRegistryContract
-
-	return ToolingBootstrap.init(
-		{
-			tools,
-			runId: RUN_ID,
-			workingDirectory: '/tmp',
-			permissionMode: 'auto',
-			env: {},
-			abortSignal: new AbortController().signal,
-			...(maxToolContentBytes !== undefined ? { maxToolContentBytes } : {}),
-		},
-		new ActivityStore(RUN_ID, { enabled: false, trackToolCalls: false, trackLlmTurns: false }),
-		async () => {},
-		makeLogger(),
-	)
-}
-
-/** An image block whose payload is comfortably over any cap set below. */
-function oversizedImage(): ToolResult {
-	return {
-		success: true,
-		output: 'captured',
-		content: [
-			{ type: 'text', text: 'captured' },
-			{ type: 'image', mediaType: 'image/png', data: 'A'.repeat(4096) },
-		],
-	} as unknown as ToolResult
-}
-
-describe('the rich-content budget is reachable from the bootstrap config', () => {
-	it('withholds an over-budget image when a host sets the cap', async () => {
-		const exec = bootstrapReturning(oversizedImage(), 512)
-		const batch = await exec.executeBatch(response())
-
-		const content = batch.messages[0]?.content
-		expect(Array.isArray(content)).toBe(true)
-		const blocks = content as ReadonlyArray<{ type: string; text?: string }>
-		expect(blocks.some((b) => b.type === 'image')).toBe(false)
-		expect(blocks[0]?.text).toContain('rich content withheld')
-		// The message names both the measurement and the cap, so an operator
-		// can tell "too big" from "cap set too low" without a repro.
-		expect(blocks[0]?.text).toContain('512')
-	})
-
-	it('passes the same payload through untouched when no cap is set', async () => {
-		const exec = bootstrapReturning(oversizedImage())
-		const batch = await exec.executeBatch(response())
-
-		const blocks = batch.messages[0]?.content as ReadonlyArray<{ type: string }>
-		expect(blocks.some((b) => b.type === 'image')).toBe(true)
-	})
-})