@namzu/sdk 43.0.0 → 44.0.0

package/src/runtime/query/token-budget.ts

@@ -1,43 +1,35 @@
-import { join } from 'node:path'
-import type { TokenBudget } from '../../run/token-budget.js'
-import { DefaultPathBuilder } from '../../session/workspace/path-builder.js'
-import { DiskCheckpointStore } from '../../store/run/checkpoint-disk.js'
-import { openTokenBudget } from '../../store/run/token-budget-disk.js'
-import type { IterationCheckpoint } from '../../types/hitl/index.js'
-import type { RunId } from '../../types/ids/index.js'
-import type { RunState } from '../../types/run/state.js'
-import { validateTokenBudgetBinding } from '../../types/run/token-budget-store.js'
+import {
+	type SessionTokenBudget,
+	type SessionTokenBudgetStore,
+	openSessionTokenBudget,
+} from '../../store/budget/index.js'
+import type { TurnId } from '../../types/ids/index.js'
+import type { TurnBudgetBinding } from '../../types/session/turn.js'
+import { asSessionId, asTurnId } from '../../utils/id.js'
 import type { QueryParams } from './index.js'
 
-/** Resolve one authority before any model request or recovered tool dispatch. */
+/** The ledger reference a checkpoint (or a selected resume state) carries. */
+export interface SavedBudgetReference {
+	readonly binding?: TurnBudgetBinding
+	readonly accountId?: string
+}
+
+/**
+ * Resolve one ledger authority before any model request or recovered tool
+ * dispatch.
+ *
+ * The ledger is keyed by `(rootSessionId, rootTurnId)`: a root turn opens its
+ * own ledger with its own limit; a child session's turns bind to the key of
+ * the root turn that spawned them (they are handed that account); a resumed
+ * paused turn reuses its key. A limit that changes between two turns of one
+ * session is therefore two ledgers, never a mismatch.
+ */
 export async function resolveQueryBudget(
 	params: QueryParams,
-	runId: RunId,
-	selected?: RunState,
-): Promise<TokenBudget> {
-	let saved: Pick<IterationCheckpoint, 'budgetBinding' | 'budgetAccountId'> | undefined = selected
-	if (params.resumeFromCheckpoint && !saved) {
-		const paths =
-			params.pathBuilder ??
-			new DefaultPathBuilder(join(params.workingDirectory ?? process.cwd(), '.namzu'))
-		const scope = {
-			tenantId: params.tenantId,
-			projectId: params.projectId,
-			sessionId: params.sessionId,
-			runId,
-			parentRunId: params.parentRunId,
-		}
-		const store =
-			params.checkpointStore ??
-			new DiskCheckpointStore(
-				{
-					baseDir: join(paths.sessionDir(params.projectId, params.sessionId), 'runs'),
-				},
-				scope,
-			)
-		saved = (await store.readCheckpoint(scope, params.resumeFromCheckpoint)) ?? undefined
-		if (!saved) throw new Error('Cannot restore a token budget from a missing checkpoint.')
-	}
+	turnId: TurnId,
+	store: SessionTokenBudgetStore,
+	saved?: SavedBudgetReference,
+): Promise<SessionTokenBudget> {
 	const schedulerBudget = params.taskScheduler?.budget
 	if (params.taskScheduler && !schedulerBudget) {
 		throw new Error('A task scheduler must expose its shared token budget account.')
@@ -46,82 +38,56 @@ export async function resolveQueryBudget(
 		throw new Error('Query and task scheduler must share the same token budget account.')
 	}
 	const provided = params.budget ?? schedulerBudget
-	const binding =
-		saved?.budgetBinding === undefined ? undefined : validateTokenBudgetBinding(saved.budgetBinding)
-	if (
-		binding &&
-		saved?.budgetAccountId !== undefined &&
-		saved.budgetAccountId !== binding.accountId
-	) {
+	const binding = saved?.binding === undefined ? undefined : validateBinding(saved.binding)
+	if (binding && saved?.accountId !== undefined && saved.accountId !== binding.accountId) {
 		throw new Error('Checkpoint token budget account references disagree.')
 	}
-	if (
-		binding &&
-		(binding.scope.tenantId !== params.tenantId || binding.scope.projectId !== params.projectId)
-	) {
-		throw new Error('Checkpoint token budget belongs to a different tenant or project.')
-	}
-	if (binding && binding.scope.runId === runId && binding.scope.sessionId !== params.sessionId) {
-		throw new Error('Checkpoint token budget belongs to a different root session.')
-	}
 	if (provided) {
-		const providedBinding = provided.binding
-		if (
-			providedBinding &&
-			(providedBinding.scope.tenantId !== params.tenantId ||
-				providedBinding.scope.projectId !== params.projectId ||
-				(providedBinding.scope.runId === runId &&
-					providedBinding.scope.sessionId !== params.sessionId))
-		) {
-			throw new Error('Supplied token budget belongs to a different root scope.')
-		}
-		if (saved?.budgetAccountId && saved.budgetAccountId !== provided.accountId) {
+		if (saved?.accountId && saved.accountId !== provided.accountId) {
 			throw new Error('Resume requires the original token budget account.')
 		}
 		if (
 			binding &&
-			(binding.accountId !== provided.accountId || binding.scope.runId !== provided.rootRunId)
+			(binding.accountId !== provided.accountId ||
+				binding.rootSessionId !== provided.scope.rootSessionId ||
+				binding.rootTurnId !== provided.scope.rootTurnId)
 		) {
 			throw new Error('Checkpoint and supplied token budget authority disagree.')
 		}
-		if (
-			binding &&
-			(!providedBinding ||
-				binding.scope.tenantId !== providedBinding.scope.tenantId ||
-				binding.scope.projectId !== providedBinding.scope.projectId ||
-				binding.scope.sessionId !== providedBinding.scope.sessionId ||
-				binding.scope.runId !== providedBinding.scope.runId)
-		) {
-			throw new Error('Checkpoint and supplied token budget root scopes disagree.')
-		}
-		provided.bindRun(runId)
-		narrowToRunLimit(provided, params.runConfig.tokenBudget)
+		provided.bindTurn(params.sessionId, turnId)
+		narrowToTurnLimit(provided, params.turnConfig.tokenBudget)
 		return provided
 	}
-	if (saved?.budgetAccountId && !binding) {
+	if (saved?.accountId && !binding) {
 		throw new Error(
 			'This checkpoint used an in-memory token budget. Supply its current authoritative budget to resume.',
 		)
 	}
-	const budget = await openTokenBudget({
-		store: params.tokenBudgetStore,
-		pathBuilder: params.pathBuilder,
-		workingDirectory: params.workingDirectory,
-		scope: binding?.scope ?? {
-			tenantId: params.tenantId,
-			projectId: params.projectId,
-			sessionId: params.sessionId,
-			runId,
-		},
-		limit: binding && binding.scope.runId !== runId ? undefined : params.runConfig.tokenBudget,
-		accountId: binding?.accountId,
-		requireExisting: binding !== undefined,
+	const ownRoot = binding === undefined || binding.rootTurnId === turnId
+	const budget = await openSessionTokenBudget({
+		store,
+		scope: binding
+			? { rootSessionId: binding.rootSessionId, rootTurnId: binding.rootTurnId }
+			: { rootSessionId: params.sessionId, rootTurnId: turnId },
+		...(ownRoot ? { limit: params.turnConfig.tokenBudget } : {}),
+		...(binding ? { accountId: binding.accountId, requireExisting: true } : {}),
 	})
-	budget.bindRun(runId)
-	narrowToRunLimit(budget, params.runConfig.tokenBudget)
+	budget.bindTurn(params.sessionId, turnId)
+	narrowToTurnLimit(budget, params.turnConfig.tokenBudget)
 	return budget
 }
 
-function narrowToRunLimit(budget: TokenBudget, limit: number): void {
+function validateBinding(binding: TurnBudgetBinding): TurnBudgetBinding {
+	if (typeof binding.accountId !== 'string' || binding.accountId.length === 0) {
+		throw new Error('Checkpoint token budget binding has no account.')
+	}
+	return {
+		rootSessionId: asSessionId(binding.rootSessionId),
+		rootTurnId: asTurnId(binding.rootTurnId),
+		accountId: binding.accountId,
+	}
+}
+
+function narrowToTurnLimit(budget: SessionTokenBudget, limit: number): void {
 	if (limit > 0 && (budget.limit === 0 || limit < budget.limit)) budget.narrow(limit)
 }

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

@@ -1,5 +1,6 @@
-import type { RunId } from '../../types/ids/index.js'
-import type { RunEvent } from '../../types/run/index.js'
+import type { TurnId } from '../../types/ids/index.js'
+import type { SessionRecord } from '../../types/session/records.js'
+import type { SessionEventDraft } from './events.js'
 
 export function assertMaxToolCalls(limit: number | undefined): void {
 	if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
@@ -7,7 +8,7 @@ export function assertMaxToolCalls(limit: number | undefined): void {
 	}
 }
 
-/** A run-owned admission ledger; durability belongs to the run's event store. */
+/** A turn-owned admission ledger; durability belongs to the session log. */
 export class ToolCallBudget {
 	private used = 0
 	private initialized?: Promise<void>
@@ -16,22 +17,21 @@ export class ToolCallBudget {
 
 	constructor(
 		private readonly limit: number,
-		private readonly runId: RunId,
-		private readonly emit: (event: RunEvent) => Promise<void>,
-		private readonly read?: () => Promise<readonly RunEvent[]>,
+		private readonly turnId: TurnId,
+		private readonly emit: (event: SessionEventDraft) => Promise<void>,
+		private readonly read?: () => Promise<readonly SessionRecord[]>,
 	) {
 		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.')
+		// The session log is read strictly (every record chained to the one
+		// before it), so it is complete; this turn's records are the ledger.
+		const events = ((await this.read?.()) ?? []).filter((record) => record.turnId === this.turnId)
+		if (events.length > 100_000)
+			throw new Error('Tool-call budget recovery exceeds 100000 records.')
 		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) ||
@@ -58,7 +58,7 @@ export class ToolCallBudget {
 		if (!initialized) {
 			await this.emit({
 				type: 'tool_calls_admitted',
-				runId: this.runId,
+				turnId: this.turnId,
 				kind: 'initialize',
 				count: 0,
 				used: 0,
@@ -94,7 +94,7 @@ export class ToolCallBudget {
 			try {
 				await this.emit({
 					type: 'tool_calls_admitted',
-					runId: this.runId,
+					turnId: this.turnId,
 					kind,
 					count,
 					used,

package/src/runtime/query/tool-executions.ts

@@ -0,0 +1,77 @@
+import type { SessionLog } from '../../store/session-log/index.js'
+import type { TurnId } from '../../types/ids/index.js'
+import type { SessionRecord } from '../../types/session/records.js'
+import type {
+	ToolExecutionRecord,
+	ToolExecutionSnapshot,
+} from '../../types/session/tool-execution.js'
+
+/**
+ * Collects the latest execution boundary of selected tool calls from one
+ * turn's records: metadata only, never retained output bodies beyond the
+ * completion's own result.
+ */
+export class ToolExecutionCollector {
+	private started = false
+	private readonly wanted: Set<string>
+	private readonly records = new Map<string, ToolExecutionRecord>()
+
+	constructor(
+		private readonly turnId: TurnId,
+		ids: readonly string[],
+	) {
+		if (ids.length > 4096) throw new Error('Tool recovery exceeds the 4096-call scan limit.')
+		this.wanted = new Set(ids)
+	}
+
+	accept(record: SessionRecord): void {
+		if (record.turnId !== this.turnId) return
+		if (record.type === 'turn_started') this.started = true
+		if (record.type !== 'tool_executing' && record.type !== 'tool_completed') return
+		const event = record as SessionRecord & Record<string, unknown>
+		if (typeof event.toolUseId !== 'string' || typeof event.toolName !== 'string')
+			throw new Error('Tool recovery found an invalid tool identity.')
+		if (!this.wanted.has(event.toolUseId)) return
+		const identity = { toolUseId: event.toolUseId, toolName: event.toolName }
+		if (record.type === 'tool_executing') {
+			// A later start invalidates an earlier completion, including retries.
+			this.records.set(event.toolUseId, { ...identity, status: 'started' })
+			return
+		}
+		if (typeof event.result !== 'string' || typeof event.isError !== 'boolean')
+			throw new Error('Tool recovery found an invalid completion.')
+		this.records.set(event.toolUseId, {
+			...identity,
+			status: 'completed',
+			result: event.result,
+			isError: event.isError,
+		})
+	}
+
+	/** Complete only when the turn's beginning was seen and the whole log verified. */
+	finish(complete = true): ToolExecutionSnapshot {
+		return { complete: complete && this.started, records: this.records }
+	}
+}
+
+/**
+ * Read the latest recorded execution boundary of selected tool calls of one
+ * turn. The log is read strictly, so absence of a start is proof only when
+ * the snapshot is `complete`.
+ */
+export async function readToolExecutions(
+	log: SessionLog,
+	turnId: TurnId,
+	ids: readonly string[],
+	signal?: AbortSignal,
+): Promise<ToolExecutionSnapshot> {
+	signal?.throwIfAborted()
+	const collector = new ToolExecutionCollector(turnId, ids)
+	const walk = log.read({ mode: 'strict' })
+	for (;;) {
+		signal?.throwIfAborted()
+		const step = await walk.next()
+		if (step.done) return collector.finish(step.value.intact && step.value.tornBytes === 0)
+		collector.accept(step.value.record)
+	}
+}

package/src/runtime/query/tool-grants.ts

@@ -32,10 +32,10 @@ export function toolGrantKeys(call: Pick<ToolCallSummary, 'name' | 'input'>): To
 }
 
 /**
- * Grants recorded during one run.
+ * Grants recorded during one turn.
  *
- * Run-scoped, not persisted: an approval is a statement about this run's
- * work, and carrying it into a later run would be reuse nobody agreed to.
+ * Turn-scoped, not persisted: an approval is a statement about this turn's
+ * work, and carrying it into a later turn would be reuse nobody agreed to.
  * The durable half is the checkpointed decision, which is evidence of what
  * was approved, not a standing permission.
  */

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

@@ -13,7 +13,7 @@ import { digest, spillManifest } from '../../store/evidence/format.js'
  * Nothing capped tool output before this. `read` returned a whole file when
  * `limit` was omitted, `bash` allowed a 100 MB buffer, and the MCP adapter
  * joined every text block uncapped — so a 2 MB lockfile became ~500k tokens
- * in a single `tool_result` and the run died on a provider error with
+ * in a single `tool_result` and the turn died on a provider error with
  * everything lost.
  */
 export const DEFAULT_MAX_TOOL_OUTPUT_CHARS = 40_000
@@ -178,7 +178,7 @@ export interface ApplyToolOutputBudgetOptions {
  * Retention keeps the original while bounding its model-visible preview.
  * The host owns the recovery route and its permissions; a spill path is not
  * proof that workspace read/grep tools can access it. Middle-elision is the
- * fallback for a run with no directory to write to.
+ * fallback for a turn with no directory to write to.
  *
  * The preview keeps head AND tail because the two ends carry different
  * information: the head has the schema/opening of a document, the tail has
@@ -269,7 +269,7 @@ function spill(
 ): { path: string; integrity?: string } | undefined {
 	try {
 		// `0o700` on the directory and `0o600` on the file: a spilled output is
-		// routinely the largest and most sensitive thing a run produces — whole
+		// routinely the largest and most sensitive thing a turn produces — whole
 		// files, whole command outputs — and the default `0o755`/`0o644` made
 		// every one of them world-readable on a shared host.
 		//
@@ -311,7 +311,7 @@ function spill(
 		// EEXIST is reported as its own sentence rather than folded into the
 		// generic message, because the two causes lead to opposite next moves:
 		// a stale file from a reused output directory is housekeeping, while
-		// something arriving at a path only this run should know is the case
+		// something arriving at a path only this turn should know is the case
 		// the exclusive open exists to refuse, and an operator has to be able
 		// to tell them apart from the log line alone.
 		const code = (err as NodeJS.ErrnoException | undefined)?.code

package/src/runtime/query/tool-pause.ts

@@ -1,5 +1,5 @@
 import type { HITLResumeDecision, ResumeHandler, UserQuestionData } from '../../types/hitl/index.js'
-import type { RunId } from '../../types/ids/index.js'
+import type { SessionId, TurnId } from '../../types/ids/index.js'
 import type { RequestToolPause, ToolPauseRequest } from '../../types/tool/index.js'
 import { generateCheckpointId } from '../../utils/id.js'
 import type { PendingAnswers, QuestionParkRecorder } from './question-park.js'
@@ -19,7 +19,7 @@ import type { PendingAnswers, QuestionParkRecorder } from './question-park.js'
  *
  * This is that same machinery behind a function on `ToolContext`. Nothing
  * new is invented: the park is a real checkpoint, the answer routes back
- * on resume, and a pause is inert outside a run that supports one.
+ * on resume, and a pause is inert outside a turn that supports one.
  */
 
 /**
@@ -71,7 +71,8 @@ export const isPauseForCall = (pause: string, callId: string): boolean =>
 	pause === callId || pause.startsWith(`${callId}:`)
 
 interface ToolPauseDeps {
-	readonly runId: RunId
+	readonly sessionId: SessionId
+	readonly turnId: TurnId
 	readonly toolUseId: string
 	readonly parkHandler: ResumeHandler
 	readonly recorder?: QuestionParkRecorder
@@ -106,7 +107,7 @@ export function createToolPause(deps: ToolPauseDeps): RequestToolPause {
 	return async (request) => {
 		const id = pauseId(deps.toolUseId, request.name)
 
-		// An answer carried in from a resumed run, checked BEFORE parking.
+		// An answer carried in from a resumed turn, checked BEFORE parking.
 		// Re-entering the tool is how the answer gets delivered — the batch
 		// re-executes — so without this the resume would ask a human
 		// something they already answered, or headlessly discard it.
@@ -120,7 +121,8 @@ export function createToolPause(deps: ToolPauseDeps): RequestToolPause {
 			carried ??
 			(await deps.parkHandler({
 				type: 'user_question',
-				runId: deps.runId,
+				sessionId: deps.sessionId,
+				turnId: deps.turnId,
 				// The question retains its correlation id; provider ids and pause
 				// names need not be safe components of a checkpoint storage key.
 				checkpointId: parkedAt ?? generateCheckpointId(),
@@ -136,7 +138,7 @@ export function createToolPause(deps: ToolPauseDeps): RequestToolPause {
 			return unanswered('the pause was resolved without an answer')
 		}
 		if (decision.questionId !== undefined && decision.questionId !== id) {
-			// Misdirection guard. Host queues are keyed by run, so a stale
+			// Misdirection guard. Host queues are keyed by turn, so a stale
 			// client can answer pause N after pause N+1 opened under the same
 			// run. Answering the wrong question is worse than not answering.
 			return unanswered('the answer was addressed to a different pause')

package/src/runtime/query/tooling.ts

@@ -1,11 +1,11 @@
 import type { AuthorizationGate } from '../../authorization/gate.js'
 import type { PluginLifecycleManager } from '../../plugin/lifecycle.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
-import type { RunId } from '../../types/ids/index.js'
+import type { SessionId, TurnId } from '../../types/ids/index.js'
 import type { InvocationState } from '../../types/invocation/index.js'
 import type { PermissionMode } from '../../types/permission/index.js'
-import type { AuditEventInput } from '../../types/run/audit.js'
-import type { RunEvent } from '../../types/run/index.js'
+import type { AuditEventInput } from '../../types/session/audit.js'
+import type { SessionRecord } from '../../types/session/records.js'
 import type {
 	RequestToolPause,
 	SkillRegistryRef,
@@ -17,16 +17,21 @@ import type { Logger } from '../../utils/logger.js'
 import type { BackgroundJobRegistry } from '../jobs/registry.js'
 import { ToolExecutor } from './executor.js'
 
-export type EmitEvent = (event: RunEvent) => Promise<void>
+import type { EmitEvent } from './events.js'
 
 export interface ToolingBootstrapConfig {
 	fileReadTracker?: import('../../types/tool/index.js').FileReadTracker
 	tools: ToolRegistryContract
-	runId: RunId
+	sessionId: SessionId
+	turnId: TurnId
 	workingDirectory: string
 	/** See `QueryParams.additionalDirectories`. */
 	additionalDirectories?: readonly string[]
-	/** A resolver, so an approval inside a run can change it. See the executor. */
+	/** See `QueryParams.outsideRootAccess`. */
+	outsideRootAccess?: 'refuse' | 'review'
+	/** See `QueryParams.sandboxEscape`. */
+	sandboxEscape?: 'refuse' | 'review'
+	/** A resolver, so an approval inside a turn can change it. See the executor. */
 	permissionMode: PermissionMode | (() => PermissionMode)
 	env: Record<string, string>
 	abortSignal: AbortSignal
@@ -34,7 +39,7 @@ export interface ToolingBootstrapConfig {
 	invocationState?: InvocationState
 	pluginManager?: PluginLifecycleManager
 	toolTimeoutMs?: number
-	/** Host-owned and shared; the executor binds it to this run. */
+	/** Host-owned and shared; the executor binds it to this turn. */
 	backgroundJobs?: BackgroundJobRegistry
 	/** See `QueryParams.backgroundJobOwner`. */
 	backgroundJobOwner?: string
@@ -42,18 +47,18 @@ export interface ToolingBootstrapConfig {
 	onJobAwaited?: (id: string) => void
 	/** Where the `skill` tool reads from. */
 	skills?: SkillRegistryRef
-	/** How this run reaches the web. */
+	/** How this turn reaches the web. */
 	web?: import('../../types/tool/index.js').ToolContext['web']
 	toolRetryBackoff?: Partial<BackoffPolicy>
 	maxToolConcurrency?: number
 	maxToolCalls?: number
-	readToolCallBudgetEvents?: () => Promise<readonly RunEvent[]>
+	readToolCallBudgetRecords?: () => Promise<readonly SessionRecord[]>
 	maxToolOutputChars?: number
 	/** See `QueryParams.toolResultGuardrails`. Absent installs the shipped default; a registry's own win. */
 	toolResultGuardrails?: readonly import('../../types/guardrail/index.js').ToolResultGuardrailSpec[]
 	retainedToolPreviewChars?: number
 	maxToolContentBytes?: number
-	captureRunEvidence?: import('../../types/tool/index.js').ToolContext['captureRunEvidence']
+	captureSessionEvidence?: import('../../types/tool/index.js').ToolContext['captureSessionEvidence']
 	toolOutputDir?: string | (() => string | undefined)
 	repairToolCall?: RepairToolCall
 	/** Operator authorization shared with the direct-call review path. */
@@ -75,17 +80,20 @@ export class ToolingBootstrap {
 			{
 				tools: config.tools,
 				...(config.fileReadTracker ? { fileReadTracker: config.fileReadTracker } : {}),
-				runId: config.runId,
+				sessionId: config.sessionId,
+				turnId: config.turnId,
 				workingDirectory: config.workingDirectory,
 				...(config.additionalDirectories?.length
 					? { additionalDirectories: config.additionalDirectories }
 					: {}),
+				...(config.outsideRootAccess ? { outsideRootAccess: config.outsideRootAccess } : {}),
+				...(config.sandboxEscape ? { sandboxEscape: config.sandboxEscape } : {}),
 				permissionMode: config.permissionMode,
 				env: config.env,
 				abortSignal: config.abortSignal,
 				allowedTools: config.allowedTools,
 				invocationState: config.invocationState,
-				captureRunEvidence: config.captureRunEvidence,
+				captureSessionEvidence: config.captureSessionEvidence,
 				pluginManager: config.pluginManager,
 				...(config.backgroundJobs ? { backgroundJobs: config.backgroundJobs } : {}),
 				...(config.backgroundJobOwner ? { backgroundJobOwner: config.backgroundJobOwner } : {}),
@@ -97,8 +105,8 @@ export class ToolingBootstrap {
 					? { toolRetryBackoff: config.toolRetryBackoff }
 					: {}),
 				...(config.maxToolCalls !== undefined ? { maxToolCalls: config.maxToolCalls } : {}),
-				...(config.readToolCallBudgetEvents
-					? { readToolCallBudgetEvents: config.readToolCallBudgetEvents }
+				...(config.readToolCallBudgetRecords
+					? { readToolCallBudgetRecords: config.readToolCallBudgetRecords }
 					: {}),
 				...(config.maxToolConcurrency !== undefined
 					? { maxToolConcurrency: config.maxToolConcurrency }