@namzu/sdk 35.0.0 → 37.0.0

package/src/runtime/query/iteration/native-output.ts

@@ -0,0 +1,35 @@
+import type { z } from 'zod'
+import type { ChatCompletionResponse } from '../../../types/provider/index.js'
+import { cloneJsonValue } from '../../../utils/json-snapshot.js'
+
+/** Native constraints are transport assistance; local validation still owns acceptance. */
+export async function parseNativeCandidate(
+	schema: z.ZodType,
+	response: ChatCompletionResponse,
+	signal: AbortSignal,
+): Promise<{ success: true; value: unknown } | { success: false }> {
+	signal.throwIfAborted()
+	if (response.finishReason !== 'stop' || response.message.toolCalls?.length)
+		return { success: false }
+	let input: unknown
+	try {
+		input = JSON.parse(response.message.content ?? '')
+	} catch {
+		return { success: false }
+	}
+	let abort!: () => void
+	const cancelled = new Promise<never>((_resolve, reject) => {
+		abort = () => reject(signal.reason ?? new Error('Native output validation cancelled'))
+		signal.addEventListener('abort', abort, { once: true })
+	})
+	try {
+		const parsed = await Promise.race([schema.safeParseAsync(input), cancelled])
+		signal.throwIfAborted()
+		if (!parsed.success) return { success: false }
+		// Match the serialized result contract of output-tool mode. Never rerun transforms.
+		const value = cloneJsonValue(parsed.data, false)
+		return { success: true, value }
+	} finally {
+		signal.removeEventListener('abort', abort)
+	}
+}

package/src/runtime/query/iteration/phases/advisory.ts

@@ -5,6 +5,7 @@ import { toolResultToText } from '../../../../types/message/content.js'
 import { createRuntimeContextMessage } from '../../../../types/message/index.js'
 import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
 import { toErrorMessage } from '../../../../utils/error.js'
+import { activeContextWindow, measureContext } from './compaction.js'
 import type { IterationContext } from './context.js'
 
 function countToolCalls(ctx: IterationContext): number {
@@ -18,9 +19,8 @@ function countToolCalls(ctx: IterationContext): number {
 }
 
 function estimateContextWindowPercent(ctx: IterationContext): number {
-	const budget = ctx.runConfig.tokenBudget
-	if (budget <= 0) return 0
-	return (ctx.runMgr.tokenUsage.totalTokens / budget) * 100
+	const window = activeContextWindow(ctx)
+	return (measureContext(ctx).tokens / window.tokens) * 100
 }
 
 function computeCostBudgetPercent(ctx: IterationContext): number | undefined {
@@ -67,7 +67,7 @@ export async function runAdvisoryPhase(
 		contextWindowPercent: estimateContextWindowPercent(ctx),
 		totalCostUsd: ctx.runMgr.costInfo.totalCost,
 		costBudgetPercent: computeCostBudgetPercent(ctx),
-		lastError: extractLastErrorFromMessages(ctx),
+		lastError: extractCurrentToolErrors(ctx, response),
 		lastToolCategory: extractLastToolCategory(ctx, response),
 		advisoryCallCount: advisoryCtx.callHistory.length,
 	}
@@ -190,16 +190,26 @@ export async function runAdvisoryPhase(
 	}
 }
 
-function extractLastErrorFromMessages(ctx: IterationContext): string | undefined {
+function extractCurrentToolErrors(
+	ctx: IterationContext,
+	response: ChatCompletionResponse,
+): string | undefined {
+	const calls = new Map(response.message.toolCalls?.map((call) => [call.id, call.function.name]))
+	if (calls.size === 0) return undefined
 	const messages = ctx.runMgr.messages
+	const errors: string[] = []
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i]
-		if (msg?.role === 'tool') {
-			// Tool results can now carry content blocks; the error sentinel is
-			// a text convention, so flatten before matching it.
-			const text = toolResultToText(msg.content)
-			if (text.startsWith('Error:')) return text
+		// The current assistant turn starts this batch. Never resurrect an old
+		// failure, even if a provider reused a call ID in another iteration.
+		if (msg?.role === 'assistant') break
+		if (msg?.role === 'tool' && msg.isError === true && calls.has(msg.toolCallId)) {
+			errors.push(
+				toolResultToText(msg.content).trim() ||
+					`Tool ${calls.get(msg.toolCallId)} reported an error.`,
+			)
 		}
 	}
-	return undefined
+	// A successful sibling does not erase failed results in this same batch.
+	return errors.length > 0 ? errors.reverse().join('\n') : undefined
 }

package/src/runtime/query/iteration/phases/compaction.ts

@@ -28,6 +28,16 @@ import { isWorkingMemoryMessage } from './working-memory.js'
 // because `runtime/query/index.ts` already imports it from this path.
 export { isCompactionMessage } from '../../../../compaction/summary.js'
 
+/** The selected request model owns the denominator, including overflow recovery. */
+export function activeContextWindow(ctx: IterationContext) {
+	const model = ctx.contextModel ?? ctx.runConfig.model
+	return resolveContextWindow(
+		ctx.compactionConfig?.contextWindowTokens,
+		model,
+		model === ctx.runConfig.model ? ctx.providerContextWindow : ctx.activeProviderContextWindow,
+	)
+}
+
 /**
  * How much a forced pass must shed before the turn is worth retrying.
  *
@@ -147,7 +157,12 @@ async function commitToolResultClear(
 	plan: ToolResultClearPlan,
 	contextWindowTokens: number,
 	windowSource: 'config' | 'provider' | 'model-table' | 'default',
+	reason: 'threshold' | 'overflow',
 ): Promise<void> {
+	// A shorter replacement also removes evidence. Preserve its original
+	// content in the same archive used by whole-message compaction before
+	// changing the live history or publishing the clear.
+	await recordShed(ctx, [...ctx.runMgr.messages], plan.messages, reason)
 	installMessages(ctx.runMgr.messages, plan.messages)
 	// The provider counted the pre-edit prompt. Leaving that measurement live
 	// makes the next trigger compare the old prompt against the new history.
@@ -547,11 +562,7 @@ async function runCompactionCheckInner(
 	// number. Nothing in the estate ever set `contextWindowTokens`, so the
 	// fallback WAS the behavior, and the shipped CLI's 1M budget put the
 	// trigger at ~700k. See `compaction/context-window.ts`.
-	const window = resolveContextWindow(
-		config.contextWindowTokens,
-		ctx.runConfig.model,
-		ctx.providerContextWindow,
-	)
+	const window = activeContextWindow(ctx)
 	const budget = window.tokens
 
 	const usage = estimatedTokens / budget
@@ -659,7 +670,7 @@ async function runCompactionCheckInner(
 			...(openTasks ? { openTasks } : {}),
 		})
 		if (working.reclaimedTokens > 0) {
-			await commitToolResultClear(ctx, working, budget, window.source)
+			await commitToolResultClear(ctx, working, budget, window.source, pass.reason)
 		}
 		// Under the trigger, the working set was the whole pass: the summary
 		// path is for the trigger, not for the soft target.
@@ -684,7 +695,7 @@ async function runCompactionCheckInner(
 		// the NEXT turn will correct it, and an over-eager summarization is
 		// far more costly than one late pass.
 		if (clearPlan.reliefWasEnough) {
-			await commitToolResultClear(ctx, clearPlan, budget, window.source)
+			await commitToolResultClear(ctx, clearPlan, budget, window.source, pass.reason)
 			return
 		}
 	}
@@ -736,7 +747,7 @@ async function runCompactionCheckInner(
 		// There is no opaque provider wait on this path, so publish that single
 		// complete edit now rather than discarding it.
 		if (stagedClear) {
-			await commitToolResultClear(ctx, stagedClear, budget, window.source)
+			await commitToolResultClear(ctx, stagedClear, budget, window.source, pass.reason)
 		}
 		return
 	}
@@ -823,6 +834,20 @@ async function runCompactionCheckInner(
 
 	const live = ctx.runMgr.messages
 	const oldCount = live.length
+	// Retained history can survive in full while a summary adds another copy
+	// of its facts. Even an unretained span may be smaller than the cumulative
+	// summary. Compare both candidates with the same estimator, rather than
+	// comparing provider usage against an estimate or trusting message count.
+	// When a clear was staged, require the summary itself to improve on it;
+	// otherwise publish the useful clear without consuming its savings.
+	if (estimateMessagesTokens(newMessages) >= estimateMessagesTokens(messages)) {
+		if (stagedClear && stagedClear.reclaimedTokens > 0) {
+			await commitToolResultClear(ctx, stagedClear, budget, window.source, pass.reason)
+		} else {
+			await declined(ctx, 'shed_nothing', oldCount)
+		}
+		return
+	}
 	await recordShed(ctx, [...live], newMessages, options?.force ? 'overflow' : 'threshold')
 
 	installMessages(live, newMessages)
@@ -840,12 +865,9 @@ async function runCompactionCheckInner(
 	// edits are installed and no verifier can still fail between them.
 	if (stagedClear) await emitToolResultClear(ctx, stagedClear)
 
-	// Hysteresis. A pass that only gets the context from 0.72 to 0.71 of the
-	// window leaves the trigger armed, so the next iteration compacts again
-	// — paying a summarization call and busting the prompt-cache prefix each
-	// time, for nothing. Report the shortfall rather than repeating a move
-	// that demonstrably does not work; `resetThreshold` was declared and
-	// CLI-set but read by nothing until now.
+	// Report remaining pressure after a useful edit. This diagnostic does not
+	// suppress future passes: appended evidence may become reclaimable even
+	// when the protected floor and recent history remain above the target.
 	const reachedReset = newEstimate / budget <= config.resetThreshold
 	if (!reachedReset) {
 		ctx.log.warn('Compaction did not reach its reset threshold — context may still be tight', {

package/src/runtime/query/iteration/phases/context.ts

@@ -131,6 +131,8 @@ export interface IterationContext {
 	 * drained and no tool result is extended.
 	 */
 	readonly steering?: SteeringChannel
+	/** Records operator intent only after guidance was accepted by a tool result. */
+	readonly onSteeringDelivered?: (text: string) => void
 	/** Exit notices for the run's background jobs, drained into the next tool result. */
 	readonly jobNotices?: SteeringChannel
 	readonly checkpointMgr: CheckpointManager
@@ -179,6 +181,11 @@ export interface IterationContext {
 	 * through to the table.
 	 */
 	readonly providerContextWindow?: number
+	/** Selected request model; its window must not reuse another model's metadata. */
+	contextModel?: string
+	activeProviderContextWindow?: number
+	/** Bounded, run-cached provider metadata lookup for a newly selected model. */
+	readonly resolveModelContextWindow?: (model: string) => Promise<number | undefined>
 
 	/**
 	 * Text queued for this run since its last turn.
@@ -188,6 +195,10 @@ export interface IterationContext {
 	 * after tool results and before the next turn.
 	 */
 	readonly inboundMessages?: () => readonly import('../../../../types/message/index.js').Message[]
+	/** Known topic-queue arrivals appended after the restored checkpoint history. */
+	readonly resumedInput?: readonly import('../../../../types/message/index.js').Message[]
+	/** Observes pending input without draining it; abort releases the waiter. */
+	readonly waitForInbound?: (signal: AbortSignal) => Promise<void>
 
 	/** Live project policy; separate from human inbound continuation. */
 	readonly projectInstructionContext?: ProjectInstructionContext

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

@@ -146,7 +146,11 @@ export async function* runToolReview(
 		// user message wedged between them is rejected by the provider. Same
 		// delivery a denial already uses, without the refusal.
 		for (const msg of attachRepeatNotice(
-			attachNotice(attachSteering(batch.messages, ctx.steering), ctx.jobNotices, formatJobNote),
+			attachNotice(
+				attachSteering(batch.messages, ctx.steering, ctx.onSteeringDelivered),
+				ctx.jobNotices,
+				formatJobNote,
+			),
 			notices,
 		)) {
 			ctx.runMgr.pushMessage(msg)

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

@@ -14,6 +14,10 @@ import type { IterationContext } from './context.js'
 export const WORKING_MEMORY_HEADER =
 	'[WORKING MEMORY] Authoritative state for this conversation — you produced these.'
 
+// Stored in the message, so ownership survives checkpoint JSON. Unmarked
+// inherited blocks may be opaque host ledgers and must never be guessed away.
+const TOOL_PINS_HEADER = `${WORKING_MEMORY_HEADER}\n[Tool-managed pins]`
+
 /**
  * True when `content` is the pinned working-memory slot (header identity only).
  * Shared with `compaction.ts` so the survival guard re-pins by the SAME rule.
@@ -34,16 +38,15 @@ export function isWorkingMemoryMessage(content: string | null | undefined): bool
  *
  * Failure-isolated (the `web-search` seam rule): a throwing/slow provider
  * degrades to "no refresh this turn" (keeps the prior slot), never breaks the
- * run. Early-returns when no provider is configured ⇒ byte-identical run path.
+ * run. With no provider or tool-owned slot, the history is left unchanged.
  */
 export async function refreshWorkingMemory(ctx: IterationContext): Promise<void> {
 	const provider = ctx.workingMemoryProvider
 	// What the tools pinned joins the slot beside what the host provides: a
 	// pin exists to be in front of the model every iteration, and until this
 	// the working state reached the history only through a compaction
-	// summary. No provider and no pins leaves the history untouched.
+	// summary. When the final pin is removed, retire only a tool-owned slot.
 	const pinned = ctx.workingStateManager ? renderPins(ctx.workingStateManager.getState()) : null
-	if (!provider && !pinned) return
 
 	let block = ''
 	if (provider) {
@@ -80,17 +83,32 @@ export async function refreshWorkingMemory(ctx: IterationContext): Promise<void>
 		}
 	}
 
+	if (!provider && !pinned) {
+		if (!ctx.workingStateManager) return
+		const prior = msgs[idx]?.content
+		if (typeof prior !== 'string' || !prior.startsWith(TOOL_PINS_HEADER)) return
+	}
+
 	if (!block.trim()) {
 		// Empty block ⇒ remove the slot (byte-identical-when-empty).
-		if (idx >= 0) msgs.splice(idx, 1)
+		if (idx >= 0) {
+			msgs.splice(idx, 1)
+			ctx.runMgr.clearLastPromptTokens?.()
+		}
 		return
 	}
 
-	const wm = createSystemMessage(`${WORKING_MEMORY_HEADER}\n\n${block}`, 'ephemeral')
+	const header = provider ? WORKING_MEMORY_HEADER : TOOL_PINS_HEADER
+	const content = `${header}\n\n${block}`
+	if (idx >= 0 && msgs[idx]?.content === content) return
+	const wm = createSystemMessage(content, 'ephemeral')
 	if (idx >= 0) {
 		msgs[idx] = wm
 	} else {
 		// Insert as the LAST leading system message (after static + dynamic).
 		msgs.splice(leadEnd, 0, wm)
 	}
+	// The old provider reading measured a different prefix, and an insertion
+	// also moves its tail watermark. Re-estimate until the next request reports.
+	ctx.runMgr.clearLastPromptTokens?.()
 }

package/src/runtime/query/iteration/stream-turn.ts

@@ -1,4 +1,5 @@
 import { type Span, SpanStatusCode } from '@opentelemetry/api'
+import { assertNativeStructuredOutputSupported } from '../../../provider/capabilities.js'
 import { isProviderRequestError } from '../../../provider/errors.js'
 import { GENAI, NAMZU, chatSpanName, parentContext } from '../../../telemetry/attributes.js'
 import {
@@ -153,6 +154,7 @@ export async function* streamProviderTurn(
 		readonly onAccepted: (identity: RequestImageIdentity) => Promise<void>
 	},
 ): AsyncGenerator<RunEvent, StreamingTurnResult> {
+	assertNativeStructuredOutputSupported(provider, params)
 	// The `chat {model}` span the GenAI conventions require. There was none:
 	// `chatSpanName` existed with zero call sites, so a trace carried no LLM
 	// latency at all and the token counts landed on the iteration span
@@ -518,11 +520,15 @@ export async function* streamProviderTurn(
 		streamCause = err
 	} finally {
 		if (onAbort) signal?.removeEventListener('abort', onAbort)
-		// Release the underlying connection on every exit (natural end, error,
-		// or abort). `for await` did this implicitly on natural completion; the
-		// manual drive must do it explicitly. `.return()` on an already-finished
-		// provider generator is a no-op.
-		await it.return?.().catch(() => {})
+		// Request cleanup on every exit, but never wait for a blocked provider's
+		// pending next(). An async generator queues return() behind that pull;
+		// awaiting it would undo the cancellation race above. Provider metering
+		// independently records cancellation and any already-issued late receipt.
+		try {
+			void it.return?.().catch(() => {})
+		} catch {
+			// Cleanup cannot replace the original stream outcome.
+		}
 	}
 
 	// Flush any tool buckets the provider failed to close (no toolCallEnd

package/src/runtime/query/prompt.ts

@@ -41,7 +41,8 @@ export interface PromptBuilderConfig {
 	contributions?: PromptContributionRegistry
 }
 
-function buildEnvContext(workingDirectory: string, runtimeContext?: AgentRuntimeContext): string {
+function buildEnvContext(workingDirectory: string, config: PromptBuilderConfig): string {
+	const { runtimeContext, tools, allowedTools } = config
 	const lines = [
 		`<env>
 Working directory: ${workingDirectory}
@@ -69,7 +70,23 @@ Platform: ${process.platform}`,
 
 	lines.push(`</env>
 
-IMPORTANT: Always use absolute paths based on the working directory above. Before reading a file, use the glob tool to discover actual file paths — never guess or hallucinate paths.`)
+Resolve relative paths against the working directory above; use supplied absolute paths as given.`)
+
+	if (hasFilesystemTools(tools, allowedTools)) {
+		lines.push(
+			'When file contents are needed, read known file paths directly. Discover unknown paths with available filesystem tools using targeted directories and patterns.',
+		)
+		const canGlob =
+			tools.has('glob') &&
+			(!allowedTools || allowedTools.includes('glob')) &&
+			tools.getAvailability('glob') === 'active'
+		lines.push(
+			canGlob
+				? "For an immediate directory overview, use glob with pattern '*' or an available directory listing tool. Use '**' only when recursive discovery is needed."
+				: 'For an immediate directory overview, use an available directory listing tool.',
+			"Keep discovery within the task's scope; do not recursively inventory unrelated home directories or cache trees.",
+		)
+	}
 
 	return lines.join('\n')
 }
@@ -224,7 +241,7 @@ export class PromptBuilder {
 				hasFilesystemTools(this.config.tools, this.config.allowedTools) ||
 				Boolean(this.config.runtimeContext)
 			if (shouldIncludeEnv) {
-				parts.push(buildEnvContext(workingDirectory, this.config.runtimeContext))
+				parts.push(buildEnvContext(workingDirectory, this.config))
 			}
 		}
 
@@ -290,7 +307,7 @@ export class PromptBuilder {
 				hasFilesystemTools(this.config.tools, this.config.allowedTools) ||
 				Boolean(this.config.runtimeContext)
 			if (shouldIncludeEnv) {
-				dynamicParts.push(buildEnvContext(workingDirectory, this.config.runtimeContext))
+				dynamicParts.push(buildEnvContext(workingDirectory, this.config))
 			}
 		}
 

package/src/runtime/query/steering.ts

@@ -1,4 +1,15 @@
-import type { Message } from '../../types/message/index.js'
+import type { Message, UserMessage } from '../../types/message/index.js'
+
+/** User-role runtime reports are context, not new operator intent. */
+export function isOperatorUserMessage(message: Message): message is UserMessage {
+	if (message.role !== 'user') return false
+	const source = message.source
+	return (
+		!source ||
+		source.type === 'goal-round' ||
+		(source.type === 'runtime-context' && source.kind === 'steering')
+	)
+}
 
 /**
  * Guidance a host hands to a turn that is already running.
@@ -134,6 +145,8 @@ export function formatSteeringNote(text: string): string {
 export function attachSteering(
 	messages: readonly Message[],
 	channel: SteeringChannel | undefined,
+	/** Receives accepted operator text, never inferred from a tool's output. */
+	onDelivered?: (text: string) => void,
 ): readonly Message[] {
 	if (!channel?.pending) return messages
 
@@ -162,6 +175,10 @@ export function attachSteering(
 	}
 
 	const next = [...messages]
-	next[lastToolIndex] = { ...target, content: target.content + formatSteeringNote(guidance) }
+	next[lastToolIndex] = {
+		...target,
+		content: target.content + formatSteeringNote(guidance),
+	}
+	onDelivered?.(guidance)
 	return next
 }

package/src/runtime/query/tool-call-budget.ts

@@ -0,0 +1,115 @@
+import type { RunId } from '../../types/ids/index.js'
+import type { RunEvent } from '../../types/run/index.js'
+
+export function assertMaxToolCalls(limit: number | undefined): void {
+	if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+		throw new RangeError('maxToolCalls must be a nonnegative safe integer.')
+	}
+}
+
+/** A run-owned admission ledger; durability belongs to the run's event store. */
+export class ToolCallBudget {
+	private used = 0
+	private initialized?: Promise<void>
+	private chain: Promise<void> = Promise.resolve()
+	private failed: unknown
+
+	constructor(
+		private readonly limit: number,
+		private readonly runId: RunId,
+		private readonly emit: (event: RunEvent) => Promise<void>,
+		private readonly read?: () => Promise<readonly RunEvent[]>,
+	) {
+		assertMaxToolCalls(limit)
+	}
+
+	private async initialize(): Promise<void> {
+		const events = (await this.read?.()) ?? []
+		if (events.length > 100_000) throw new Error('Tool-call budget recovery exceeds 100000 events.')
+		let initialized = false
+		let expectedSeq = 0
+		for (const event of events) {
+			// A replayed transcript must be complete and belong to this run.
+			if (event.runId !== this.runId || event.seq !== ++expectedSeq)
+				throw new Error('Tool-call budget recovery requires a complete run event log.')
+			if (event.type === 'tool_calls_admitted') {
+				if (
+					!Number.isSafeInteger(event.count) ||
+					event.count < 0 ||
+					!Number.isSafeInteger(event.used) ||
+					event.used !== this.used + event.count ||
+					!Number.isSafeInteger(event.limit) ||
+					event.limit < event.used ||
+					!['initialize', 'batch', 'nested', 'retry'].includes(event.kind) ||
+					(event.kind === 'initialize'
+						? initialized || event.count !== 0
+						: !initialized || event.count === 0)
+				)
+					throw new Error('Invalid tool-call admission ledger.')
+				initialized = true
+				this.used = event.used
+			} else if (
+				!initialized &&
+				(event.type === 'tool_executing' || event.type === 'tool_completed')
+			) {
+				throw new Error('Cannot establish tool-call usage for an earlier unbudgeted execution.')
+			}
+		}
+		if (!initialized) {
+			await this.emit({
+				type: 'tool_calls_admitted',
+				runId: this.runId,
+				kind: 'initialize',
+				count: 0,
+				used: 0,
+				limit: this.limit,
+			})
+		}
+	}
+
+	/** Reserve before work, never refund. A refused group consumes no new slots. */
+	async admit(
+		count: number,
+		kind: 'batch' | 'nested' | 'retry',
+		signal: AbortSignal,
+	): Promise<string | undefined> {
+		signal.throwIfAborted()
+		const previous = this.chain
+		let release!: () => void
+		this.chain = new Promise<void>((resolve) => {
+			release = resolve
+		})
+		try {
+			await previous
+			signal.throwIfAborted()
+			if (this.failed !== undefined) throw this.failed
+			this.initialized ??= this.initialize()
+			await this.initialized
+			signal.throwIfAborted()
+			if (count > Math.max(0, this.limit - this.used)) {
+				return `Tool-call budget exhausted: this ${kind} needs ${count} slots; ${Math.max(0, this.limit - this.used)} remain of maxToolCalls=${this.limit}. No calls in this admission were executed.`
+			}
+			if (count === 0) return undefined
+			const used = this.used + count
+			try {
+				await this.emit({
+					type: 'tool_calls_admitted',
+					runId: this.runId,
+					kind,
+					count,
+					used,
+					limit: this.limit,
+				})
+			} catch (error) {
+				// An uncertain write must not be retried as a fresh allowance.
+				this.failed = error ?? new Error('Tool-call admission persistence failed.')
+				throw this.failed
+			}
+			this.used = used
+			signal.throwIfAborted()
+			return undefined
+		} finally {
+			release()
+		}
+	}
+}

package/src/runtime/query/tooling.ts

@@ -43,6 +43,8 @@ export interface ToolingBootstrapConfig {
 	web?: import('../../types/tool/index.js').ToolContext['web']
 	toolRetryBackoff?: Partial<BackoffPolicy>
 	maxToolConcurrency?: number
+	maxToolCalls?: number
+	readToolCallBudgetEvents?: () => Promise<readonly RunEvent[]>
 	maxToolOutputChars?: number
 	maxToolContentBytes?: number
 	toolOutputDir?: string
@@ -84,6 +86,10 @@ export class ToolingBootstrap {
 				...(config.toolRetryBackoff !== undefined
 					? { toolRetryBackoff: config.toolRetryBackoff }
 					: {}),
+				...(config.maxToolCalls !== undefined ? { maxToolCalls: config.maxToolCalls } : {}),
+				...(config.readToolCallBudgetEvents
+					? { readToolCallBudgetEvents: config.readToolCallBudgetEvents }
+					: {}),
 				...(config.maxToolConcurrency !== undefined
 					? { maxToolConcurrency: config.maxToolConcurrency }
 					: {}),