@namzu/sdk 14.0.7 → 15.0.0

package/src/runtime/query/__tests__/tool-repair-retry.test.ts

@@ -1,255 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-
-import { ToolRegistry } from '../../../registry/tool/execute.js'
-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 { ToolDefinition, ToolResult } from '../../../types/tool/index.js'
-import type { RepairToolCall } from '../../../types/tool/repair.js'
-import type { Logger } from '../../../utils/logger.js'
-import { ToolExecutor, type ToolExecutorConfig } from '../executor.js'
-
-/**
- * Two failure modes that both used to cost a full model round trip.
- *
- * A malformed tool call went back as a `tool_result` error; the model
- * re-read the entire context and issued a second inference to add a
- * missing brace. A transient tool failure did the same, except the model
- * also had to decide on its own that retrying was worth it.
- */
-
-const RUN_ID = 'run_repair' 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(name: string, args: string): ChatCompletionResponse {
-	return {
-		id: 'resp_1',
-		model: 'mock',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [{ id: 'call_1', type: 'function', function: { name, arguments: args } }],
-		},
-		finishReason: 'tool_calls',
-		usage: {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		},
-	}
-}
-
-function makeExecutor(
-	registry: ToolRegistry,
-	extra: Partial<ToolExecutorConfig> = {},
-): { executor: ToolExecutor } {
-	const executor = new ToolExecutor(
-		{
-			tools: registry,
-			runId: RUN_ID,
-			workingDirectory: process.cwd(),
-			permissionMode: 'auto',
-			env: {},
-			abortSignal: new AbortController().signal,
-			...extra,
-		},
-		new ActivityStore(RUN_ID, { enabled: false, trackToolCalls: false, trackLlmTurns: false }),
-		() => Promise.resolve(),
-		makeLogger(),
-	)
-	return { executor }
-}
-
-/** A tool that fails `failures` times, then succeeds. */
-function flakyTool(opts: { failures: number; retryable: boolean; maxRetries?: number }) {
-	const attempts: number[] = []
-	let seen = 0
-	const tool = {
-		name: 'fetch_page',
-		description: 'Fetch a page',
-		inputSchema: z.object({ url: z.string() }),
-		...(opts.maxRetries !== undefined ? { maxRetries: opts.maxRetries } : {}),
-		execute: (): Promise<ToolResult> => {
-			seen++
-			attempts.push(seen)
-			if (seen <= opts.failures) {
-				return Promise.resolve({
-					success: false,
-					output: '',
-					error: 'connection reset',
-					retryable: opts.retryable,
-				})
-			}
-			return Promise.resolve({ success: true, output: `fetched on attempt ${seen}` })
-		},
-	} as unknown as ToolDefinition
-	return { tool, attempts }
-}
-
-let registry: ToolRegistry
-
-beforeEach(() => {
-	registry = new ToolRegistry()
-})
-
-describe('repairToolCall', () => {
-	const readFile = {
-		name: 'read_file',
-		description: 'Read a file',
-		inputSchema: z.object({ path: z.string() }),
-		execute: (input: unknown) =>
-			Promise.resolve({ success: true, output: `read ${(input as { path: string }).path}` }),
-	} as unknown as ToolDefinition
-
-	beforeEach(() => {
-		registry.register(readFile)
-	})
-
-	it('fixes unparseable arguments instead of spending a round trip on it', async () => {
-		const repair: RepairToolCall = ({ reason }) =>
-			reason === 'invalid_json' ? { arguments: '{"path":"a.ts"}' } : null
-
-		const { executor } = makeExecutor(registry, { repairToolCall: repair })
-		const batch = await executor.executeBatch(response('read_file', '{"path": "a.ts'))
-
-		expect(batch.results[0]?.isError).toBeFalsy()
-		expect(batch.results[0]?.output).toBe('read a.ts')
-	})
-
-	it('hands the repairer the schema to aim at', async () => {
-		const seen = vi.fn<RepairToolCall>(() => null)
-		const { executor } = makeExecutor(registry, { repairToolCall: seen })
-		await executor.executeBatch(response('read_file', '{bad'))
-
-		expect(seen).toHaveBeenCalledOnce()
-		const ctx = seen.mock.calls[0]?.[0]
-		expect(ctx?.reason).toBe('invalid_json')
-		expect(ctx?.jsonSchema).toMatchObject({ properties: { path: { type: 'string' } } })
-		expect(ctx?.availableTools).toContain('read_file')
-	})
-
-	it('can correct a near-miss tool name', async () => {
-		const repair: RepairToolCall = ({ reason, availableTools }) =>
-			reason === 'unknown_tool'
-				? { toolName: availableTools[0] as string, arguments: '{"path":"b.ts"}' }
-				: null
-
-		const { executor } = makeExecutor(registry, { repairToolCall: repair })
-		const batch = await executor.executeBatch(response('readFile', '{"path":"b.ts"}'))
-
-		expect(batch.results[0]?.output).toBe('read b.ts')
-		expect(batch.results[0]?.toolName).toBe('read_file')
-	})
-
-	it('repairs arguments that parse but violate the schema', async () => {
-		const repair: RepairToolCall = ({ reason }) =>
-			reason === 'schema_validation' ? { arguments: '{"path":"c.ts"}' } : null
-
-		const { executor } = makeExecutor(registry, { repairToolCall: repair })
-		const batch = await executor.executeBatch(response('read_file', '{"path": 42}'))
-
-		expect(batch.results[0]?.output).toBe('read c.ts')
-	})
-
-	it('declining is normal — the original error proceeds unchanged', async () => {
-		const { executor } = makeExecutor(registry, { repairToolCall: () => null })
-		const batch = await executor.executeBatch(response('read_file', '{bad'))
-
-		expect(batch.results[0]?.isError).toBe(true)
-		expect(batch.results[0]?.output).toContain('Invalid JSON')
-	})
-
-	it('tries exactly once — a still-broken repair does not loop', async () => {
-		// An unbounded repair loop is a hang, not a degradation.
-		const repair = vi.fn<RepairToolCall>(() => ({ arguments: 'still not json' }))
-		const { executor } = makeExecutor(registry, { repairToolCall: repair })
-		const batch = await executor.executeBatch(response('read_file', '{bad'))
-
-		expect(repair).toHaveBeenCalledOnce()
-		expect(batch.results[0]?.isError).toBe(true)
-	})
-
-	it('a throwing repairer does not take the run down', async () => {
-		const { executor } = makeExecutor(registry, {
-			repairToolCall: () => {
-				throw new Error('repair model unavailable')
-			},
-		})
-		const batch = await executor.executeBatch(response('read_file', '{bad'))
-
-		// The original error was always a perfectly good answer to give.
-		expect(batch.results[0]?.output).toContain('Invalid JSON')
-	})
-
-	it('with no repairer configured, behavior is exactly as before', async () => {
-		const { executor } = makeExecutor(registry)
-		const ok = await executor.executeBatch(response('read_file', '{"path":"d.ts"}'))
-		expect(ok.results[0]?.output).toBe('read d.ts')
-
-		const bad = await executor.executeBatch(response('read_file', '{bad'))
-		expect(bad.results[0]?.output).toContain('Invalid JSON')
-
-		// Schema errors still come from the registry, which has the better
-		// message — a "Required: ..." hint the model can self-correct from.
-		const invalid = await executor.executeBatch(response('read_file', '{"path": 42}'))
-		expect(invalid.results[0]?.isError).toBe(true)
-	})
-})
-
-describe('per-tool retry budget', () => {
-	it('retries a retryable failure in-loop and reports the success', async () => {
-		const { tool, attempts } = flakyTool({ failures: 2, retryable: true, maxRetries: 3 })
-		registry.register(tool)
-
-		const { executor } = makeExecutor(registry)
-		const batch = await executor.executeBatch(response('fetch_page', '{"url":"x"}'))
-
-		expect(attempts).toHaveLength(3)
-		expect(batch.results[0]?.output).toBe('fetched on attempt 3')
-		expect(batch.results[0]?.isError).toBeFalsy()
-	})
-
-	it('does NOT retry unless the tool opted in — the default is 0', async () => {
-		// The SDK cannot know a tool is idempotent. Silently re-running a
-		// write or a payment is worse than never retrying.
-		const { tool, attempts } = flakyTool({ failures: 1, retryable: true })
-		registry.register(tool)
-
-		const { executor } = makeExecutor(registry)
-		const batch = await executor.executeBatch(response('fetch_page', '{"url":"x"}'))
-
-		expect(attempts).toHaveLength(1)
-		expect(batch.results[0]?.isError).toBe(true)
-	})
-
-	it('does not spend the budget on a failure that will never succeed', async () => {
-		// A missing file does not appear on the second attempt; retrying
-		// only delays the error the model needs to see.
-		const { tool, attempts } = flakyTool({ failures: 5, retryable: false, maxRetries: 3 })
-		registry.register(tool)
-
-		const { executor } = makeExecutor(registry)
-		await executor.executeBatch(response('fetch_page', '{"url":"x"}'))
-
-		expect(attempts).toHaveLength(1)
-	})
-
-	it('gives up after the budget and hands the error to the model', async () => {
-		const { tool, attempts } = flakyTool({ failures: 99, retryable: true, maxRetries: 2 })
-		registry.register(tool)
-
-		const { executor } = makeExecutor(registry)
-		const batch = await executor.executeBatch(response('fetch_page', '{"url":"x"}'))
-
-		expect(attempts).toHaveLength(3) // the first try plus two retries
-		expect(batch.results[0]?.isError).toBe(true)
-		expect(batch.results[0]?.output).toContain('connection reset')
-	})
-})

package/src/runtime/query/__tests__/tool-result-wire.test.ts

@@ -1,135 +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 { ToolExecutor } from '../executor.js'
-
-/**
- * The seam between what a tool RETURNS and what reaches the provider.
- *
- * Both halves of the content-block migration were landing here and neither
- * was covered: the executor's local `result` was typed as a narrowed
- * literal that silently dropped `content`, and its final return omitted
- * `isError` entirely. So a tool could return an image block and a failure
- * flag, the wire mappers were built to carry both, and neither ever
- * arrived — the mapper tests passed because they set the fields by hand.
- */
-
-const RUN_ID = 'run_wire' 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(name: string): ChatCompletionResponse {
-	return {
-		id: 'r',
-		model: 'm',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: [{ id: 'call_1', type: 'function', function: { name, arguments: '{}' } }],
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-function executorReturning(result: ToolResult, maxToolOutputChars?: number): ToolExecutor {
-	const tools = {
-		get: vi.fn(() => ({
-			name: 'tool',
-			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 new ToolExecutor(
-		{
-			tools,
-			runId: RUN_ID,
-			workingDirectory: '/tmp',
-			permissionMode: 'auto',
-			env: {},
-			abortSignal: new AbortController().signal,
-			...(maxToolOutputChars !== undefined ? { maxToolOutputChars } : {}),
-		},
-		new ActivityStore(RUN_ID, { enabled: false, trackToolCalls: false, trackLlmTurns: false }),
-		async () => {},
-		makeLogger(),
-	)
-}
-
-describe('a failed tool is marked as failed on the message', () => {
-	it('sets isError on the tool message', async () => {
-		const exec = executorReturning({ success: false, output: '', error: 'no such file' })
-		const batch = await exec.executeBatch(response('read'))
-
-		expect(batch.results[0]?.isError).toBe(true)
-		expect(batch.messages[0]).toMatchObject({ role: 'tool', isError: true })
-	})
-
-	it('leaves isError false on success', async () => {
-		const exec = executorReturning({ success: true, output: 'fine' })
-		const batch = await exec.executeBatch(response('read'))
-
-		expect(batch.results[0]?.isError).toBe(false)
-		expect(batch.messages[0]).toMatchObject({ isError: false })
-	})
-})
-
-describe('rich tool content reaches the message', () => {
-	const IMAGE: ToolResult = {
-		success: true,
-		output: 'Screenshot captured (1920x1080, image/png).',
-		content: [
-			{ type: 'text', text: 'Screenshot captured.' },
-			{ type: 'image', data: 'AAAA', mediaType: 'image/png' },
-		],
-	}
-
-	it('puts the blocks on the message, not the text summary', async () => {
-		const exec = executorReturning(IMAGE)
-		const batch = await exec.executeBatch(response('computer_use'))
-
-		const content = batch.messages[0]?.content
-		expect(Array.isArray(content)).toBe(true)
-		expect(content).toEqual(IMAGE.content)
-	})
-
-	it('still reports the text form on the result, for the transcript', async () => {
-		const exec = executorReturning(IMAGE)
-		const batch = await exec.executeBatch(response('computer_use'))
-		expect(batch.results[0]?.output).toContain('1920x1080')
-	})
-
-	it('falls back to the string when the tool returned no blocks', async () => {
-		const exec = executorReturning({ success: true, output: 'plain text' })
-		const batch = await exec.executeBatch(response('read'))
-		expect(batch.messages[0]?.content).toBe('plain text')
-	})
-
-	it('drops rich content when the output was spilled — the preview is not the payload', async () => {
-		const exec = executorReturning(
-			{ success: true, output: 'x'.repeat(5_000), content: [{ type: 'text', text: 'x' }] },
-			200,
-		)
-		const batch = await exec.executeBatch(response('read'))
-
-		// The model must see the budgeted preview, not a block array that
-		// still carries the full payload.
-		expect(typeof batch.messages[0]?.content).toBe('string')
-		expect(String(batch.messages[0]?.content)).toContain('characters omitted')
-	})
-})

package/src/runtime/query/__tests__/tool-timeout.test.ts

@@ -1,268 +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 } from '../../../types/tool/index.js'
-import type { Logger } from '../../../utils/logger.js'
-import { DEFAULT_TOOL_TIMEOUT_MS, ToolExecutor } from '../executor.js'
-
-/**
- * `ToolContext.abortSignal` was produced by the executor and consumed by
- * nothing — a repo-wide grep found only the two producer sites. A Stop tore
- * down the model stream and then parked inside `Promise.all` waiting on a
- * tool that had no idea it should quit, and no framework-level deadline
- * existed at all: `bash` defaulted to one hour, MCP stdio to forever.
- */
-
-const RUN_ID = 'run_timeout' 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(...names: string[]): ChatCompletionResponse {
-	return {
-		id: 'r',
-		model: 'm',
-		message: {
-			role: 'assistant',
-			content: null,
-			toolCalls: names.map((name, i) => ({
-				id: `call_${i}`,
-				type: 'function' as const,
-				function: { name, arguments: '{}' },
-			})),
-		},
-		finishReason: 'tool_calls',
-		usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-	} as ChatCompletionResponse
-}
-
-interface Harness {
-	exec: ToolExecutor
-	/** Signals handed to each tool invocation, in call order. */
-	signals: AbortSignal[]
-	peakConcurrency: () => number
-}
-
-function harness(opts: {
-	run: (name: string, signal: AbortSignal) => Promise<{ success: boolean; output: string }>
-	toolTimeoutMs?: number
-	perToolTimeoutMs?: Record<string, number>
-	maxToolConcurrency?: number
-	abortSignal?: AbortSignal
-	concurrencySafe?: boolean
-}): Harness {
-	const signals: AbortSignal[] = []
-	let inFlight = 0
-	let peak = 0
-
-	const tools = {
-		get: vi.fn((name: string) => ({
-			name,
-			isConcurrencySafe: () => opts.concurrencySafe ?? true,
-			isReadOnly: () => true,
-			isDestructive: () => false,
-			...(opts.perToolTimeoutMs?.[name] !== undefined
-				? { timeoutMs: opts.perToolTimeoutMs[name] }
-				: {}),
-		})),
-		execute: vi.fn(async (name: string, _input: unknown, ctx: { abortSignal: AbortSignal }) => {
-			signals.push(ctx.abortSignal)
-			inFlight++
-			peak = Math.max(peak, inFlight)
-			try {
-				return await opts.run(name, ctx.abortSignal)
-			} finally {
-				inFlight--
-			}
-		}),
-		has: vi.fn(() => true),
-		listNames: vi.fn(() => []),
-		getAvailability: vi.fn(() => 'active'),
-		register: vi.fn(),
-		unregister: vi.fn(),
-	} as unknown as ToolRegistryContract
-
-	const exec = new ToolExecutor(
-		{
-			tools,
-			runId: RUN_ID,
-			workingDirectory: '/tmp',
-			permissionMode: 'auto',
-			env: {},
-			abortSignal: opts.abortSignal ?? new AbortController().signal,
-			...(opts.toolTimeoutMs !== undefined ? { toolTimeoutMs: opts.toolTimeoutMs } : {}),
-			...(opts.maxToolConcurrency !== undefined
-				? { maxToolConcurrency: opts.maxToolConcurrency }
-				: {}),
-		},
-		new ActivityStore(RUN_ID, { enabled: true, trackToolCalls: true, trackLlmTurns: true }),
-		async () => {},
-		makeLogger(),
-	)
-
-	return { exec, signals, peakConcurrency: () => peak }
-}
-
-const never = () => new Promise<never>(() => {})
-
-describe('ToolExecutor — per-tool deadline', () => {
-	it('abandons a hung tool and reports the timeout as a tool_result', async () => {
-		const h = harness({ toolTimeoutMs: 20, run: never })
-		const batch = await h.exec.executeBatch(response('hang'))
-
-		expect(batch.results).toHaveLength(1)
-		expect(batch.results[0]?.output).toContain('timed out after 20ms')
-		// It is still an ANSWER — the assistant turn stays complete.
-		expect(batch.messages[0]?.role).toBe('tool')
-	})
-
-	it('fires the tool context abort signal on timeout so a cooperative tool stops', async () => {
-		let observed = false
-		const h = harness({
-			toolTimeoutMs: 20,
-			run: (_name, signal) =>
-				new Promise((_resolve) => {
-					signal.addEventListener('abort', () => {
-						observed = true
-					})
-				}),
-		})
-		await h.exec.executeBatch(response('hang'))
-		expect(observed).toBe(true)
-	})
-
-	it('a per-tool timeoutMs overrides the run default', async () => {
-		const h = harness({
-			toolTimeoutMs: 5_000,
-			perToolTimeoutMs: { quick: 20 },
-			run: never,
-		})
-		const batch = await h.exec.executeBatch(response('quick'))
-		expect(batch.results[0]?.output).toContain('timed out after 20ms')
-	})
-
-	it('does not disturb a tool that finishes in time', async () => {
-		const h = harness({
-			toolTimeoutMs: 5_000,
-			run: async () => ({ success: true, output: 'done' }),
-		})
-		const batch = await h.exec.executeBatch(response('fast'))
-		expect(batch.results[0]?.output).toBe('done')
-		expect(h.signals[0]?.aborted).toBe(false)
-	})
-
-	it('cancels an in-flight tool when the RUN is aborted', async () => {
-		const controller = new AbortController()
-		const h = harness({
-			toolTimeoutMs: 60_000,
-			abortSignal: controller.signal,
-			run: never,
-		})
-		const pending = h.exec.executeBatch(response('hang'))
-		controller.abort()
-		const batch = await pending
-
-		expect(batch.results[0]?.output).toContain('was cancelled')
-	})
-
-	it('propagates an already-aborted run signal immediately', async () => {
-		const controller = new AbortController()
-		controller.abort()
-		const h = harness({ abortSignal: controller.signal, run: never })
-		const batch = await h.exec.executeBatch(response('hang'))
-		expect(batch.results[0]?.output).toContain('was cancelled')
-	})
-
-	it('says WHICH stop it was, when the caller named one', async () => {
-		// The reason was on this signal all along — it is forwarded into the
-		// per-tool controller a few lines above the message — and the message
-		// threw it away. So a deadline, a budget and an operator pressing stop
-		// all reached the model as the same four words, and they want
-		// different next moves: one is worth waiting out, one is worth
-		// narrowing the input for, and one is worth stopping over.
-		const controller = new AbortController()
-		const h = harness({
-			toolTimeoutMs: 60_000,
-			abortSignal: controller.signal,
-			run: never,
-		})
-		const pending = h.exec.executeBatch(response('hang'))
-		controller.abort(new Error('deployment window closed'))
-		const batch = await pending
-
-		expect(batch.results[0]?.output).toContain('deployment window closed')
-	})
-
-	it('does not invent a reason when the caller gave none', async () => {
-		// `abort()` with no argument fills `reason` with a DOMException named
-		// AbortError. Rendering it would turn an honest silence into something
-		// that reads like an explanation, which is the worse failure.
-		const controller = new AbortController()
-		const h = harness({
-			toolTimeoutMs: 60_000,
-			abortSignal: controller.signal,
-			run: never,
-		})
-		const pending = h.exec.executeBatch(response('hang'))
-		controller.abort()
-		const batch = await pending
-
-		expect(batch.results[0]?.output).toContain('was cancelled.')
-		expect(batch.results[0]?.output).not.toContain('AbortError')
-	})
-
-	it('exposes a sane default deadline', () => {
-		// Documented so a change is a deliberate decision, not a drift.
-		expect(DEFAULT_TOOL_TIMEOUT_MS).toBe(120_000)
-	})
-})
-
-describe('ToolExecutor — bounded fan-out', () => {
-	it('caps concurrently-running concurrency-safe tools', async () => {
-		let release: (() => void) | undefined
-		const gateOpen = new Promise<void>((r) => {
-			release = r
-		})
-		let started = 0
-
-		const h = harness({
-			maxToolConcurrency: 2,
-			toolTimeoutMs: 5_000,
-			run: async () => {
-				started++
-				await gateOpen
-				return { success: true, output: 'ok' }
-			},
-		})
-
-		const pending = h.exec.executeBatch(response('a', 'b', 'c', 'd', 'e'))
-		// Let the first wave schedule.
-		await new Promise((r) => setTimeout(r, 5))
-		expect(started).toBe(2)
-
-		release?.()
-		await pending
-		expect(h.peakConcurrency()).toBeLessThanOrEqual(2)
-	})
-
-	it('still answers every call when the batch exceeds the cap', async () => {
-		const h = harness({
-			maxToolConcurrency: 2,
-			run: async () => ({ success: true, output: 'ok' }),
-		})
-		const batch = await h.exec.executeBatch(response('a', 'b', 'c', 'd', 'e'))
-		expect(batch.messages).toHaveLength(5)
-		// Order must still match the tool_use order.
-		expect(batch.results.map((r) => r.toolCallId)).toEqual([
-			'call_0',
-			'call_1',
-			'call_2',
-			'call_3',
-			'call_4',
-		])
-	})
-})