@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/runs/foreground/executor-stage-call.ts

@@ -1,434 +0,0 @@
-import { BUDGET_WRAP_UP_PROMPT, WorkflowBudgetExceededError } from "../../engine/run-budget.js";
-import { rebasedStageStartedAt } from "../../shared/timing.js";
-import type { StageOptions, WorkflowModelUsage } from "../../shared/types.js";
-import type { ConcurrencyLimiter } from "../shared/concurrency.js";
-import { raceAbort } from "./executor-abort.js";
-import { hasExplicitFastModeCandidate } from "./executor-direct-helpers.js";
-import {
-	askReadinessViaStageBroker,
-	RESUME_CONTINUATION_PROMPT,
-	type ReadinessDecision,
-	shouldInjectResumeContinuation,
-} from "./executor-hil.js";
-import { applyFailureToStage } from "./executor-lifecycle.js";
-import { isTerminalStage } from "./executor-scheduler.js";
-import type { LiveStageRuntime } from "./executor-stage-types.js";
-import type { StageAdapters } from "./stage-runner.js";
-
-export interface TrackedStageCallOptions {
-	readonly eagerSession?: boolean;
-	readonly allowFinalized?: boolean;
-}
-
-export type TrackedStageCaller = <T>(
-	call: () => Promise<T>,
-	eagerSessionOrOptions?: boolean | TrackedStageCallOptions,
-) => Promise<T>;
-
-function normalizeTrackedStageCallOptions(
-	input: boolean | TrackedStageCallOptions | undefined,
-): Required<TrackedStageCallOptions> {
-	if (typeof input === "boolean") return { eagerSession: input, allowFinalized: false };
-	return { eagerSession: input?.eagerSession === true, allowFinalized: input?.allowFinalized === true };
-}
-
-function throwFinalizationError(error: unknown): never {
-	throw error;
-}
-
-export function createTrackedStageCaller(input: {
-	readonly runtime: LiveStageRuntime;
-	readonly limiter: ConcurrencyLimiter;
-	readonly options: StageOptions | undefined;
-	readonly adapters: StageAdapters;
-	readonly hasContinuation: boolean;
-	readonly hasScopedParents: boolean;
-}): TrackedStageCaller {
-	const { runtime } = input;
-	const readinessGateEnabled =
-		runtime.opts.confirmStageReadiness !== undefined || runtime.opts.usePromptNodesForUi === true;
-	const confirmReadiness = async (): Promise<ReadinessDecision> => {
-		try {
-			if (runtime.opts.confirmStageReadiness !== undefined) {
-				const ready = await runtime.opts.confirmStageReadiness({
-					runId: runtime.runId,
-					stageId: runtime.stageId,
-					stageName: runtime.name,
-					signal: runtime.signal,
-				});
-				return ready ? { action: "advance" } : { action: "stay" };
-			}
-			return await askReadinessViaStageBroker(runtime.runId, runtime.stageId, runtime.signal);
-		} catch {
-			return { action: "advance" };
-		}
-	};
-
-	const suppressReadinessForCurrentTurn = (): void => {
-		runtime.state.askUserQuestionObservedThisTurn = false;
-		runtime.state.chatAnswerObservedThisTurn = false;
-	};
-
-	const skipResumeContinuationInjection = (): boolean => {
-		if (runtime.state.stageFinalized) return true;
-		if (runtime.state.skippedForParallelFailFast) return true;
-		if (runtime.stageSnapshot.status === "skipped" && runtime.stageSnapshot.skippedReason === "fail-fast")
-			return true;
-		if (isTerminalStage(runtime.stageSnapshot)) return true;
-		if (runtime.stageFailFastScope?.failed === true && runtime.stageFailFastScope.activeStages.has(runtime.stageId))
-			return true;
-		if (runtime.innerCtx.__structuredOutputFinalized()) return true;
-		return false;
-	};
-
-	const drainResumeContinuations = async <T>(
-		currentResult: T,
-	): Promise<{
-		readonly result: T;
-		readonly chatAnswerObserved: boolean;
-	}> => {
-		let result = currentResult;
-		let chatAnswerObserved = runtime.state.chatAnswerObservedThisTurn;
-		const captureChatAnswer = (): void => {
-			chatAnswerObserved ||= runtime.state.chatAnswerObservedThisTurn;
-		};
-		while (runtime.state.resumeContinuationPending !== false) {
-			const reason = runtime.state.resumeContinuationPending;
-			runtime.state.resumeContinuationPending = false;
-			captureChatAnswer();
-			suppressReadinessForCurrentTurn();
-			if (
-				!shouldInjectResumeContinuation({
-					reason,
-					gateEnabled: readinessGateEnabled,
-					aborted: runtime.signal.aborted,
-				}) ||
-				skipResumeContinuationInjection()
-			)
-				continue;
-			const suppressQueuedContinuation = reason === "paused-queued-user-message";
-			if (suppressQueuedContinuation) runtime.state.suppressQueuedUserMessageContinuation = true;
-			try {
-				result = (await runtime.raceStageSessionHeartbeat(
-					raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal),
-				)) as T;
-			} finally {
-				if (suppressQueuedContinuation) runtime.state.suppressQueuedUserMessageContinuation = false;
-			}
-			captureChatAnswer();
-		}
-		captureChatAnswer();
-		return { result, chatAnswerObserved };
-	};
-	const deliverBudgetWrapUp = async (): Promise<never> => {
-		let summary: string | undefined;
-		let usage: WorkflowModelUsage | undefined;
-		try {
-			const response = await runtime.raceStageSessionHeartbeat(
-				raceAbort(runtime.innerCtx.prompt(BUDGET_WRAP_UP_PROMPT), runtime.signal),
-			);
-			summary = typeof response === "string" ? response : runtime.innerCtx.__getLastAssistantText();
-			usage = runtime.innerCtx.__modelFallbackMeta().modelAttempts?.at(-1)?.usage;
-		} catch {
-			// A failed or aborted wrap-up did not deliver a summary and must not
-			// consume the once-per-run delivery allowance.
-		}
-		throw runtime.budget.finishWrapUp(runtime.name, summary, usage, summary !== undefined);
-	};
-
-	return async <T>(call: () => Promise<T>, eagerSessionOrOptions?: boolean | TrackedStageCallOptions): Promise<T> => {
-		const callOptions = normalizeTrackedStageCallOptions(eagerSessionOrOptions);
-		runtime.exit.throwIfWorkflowExitSelected();
-		if (runtime.budget.enabled) await runtime.budget.stopAtBoundaryAsync(runtime.name);
-		await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
-		if (runtime.state.stageFinalized && !callOptions.allowFinalized) throw runtime.parallelFailFastError();
-
-		await input.limiter.acquire();
-		try {
-			await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
-			runtime.exit.throwIfWorkflowExitSelected();
-			if (runtime.state.stageFinalized && !callOptions.allowFinalized) throw runtime.parallelFailFastError();
-		} catch (err) {
-			input.limiter.release();
-			throw err;
-		}
-
-		const trackStageLifecycle = !runtime.state.stageFinalized;
-		let applyTerminalStageState: (() => void) | undefined;
-		// Set only alongside the successful "completed" terminal state, so a failed
-		// final durable checkpoint can replace it without touching a real
-		// failure/skip classification recorded by the catch block.
-		let terminalStateIsSuccess = false;
-		let stageResultBeforeBudget: string | undefined;
-		const unregisterBudgetWrapUp = runtime.budget.registerWrapUp(runtime.name, deliverBudgetWrapUp);
-		try {
-			let refreshedParentIds: readonly string[] | undefined;
-			if (
-				trackStageLifecycle &&
-				!input.hasContinuation &&
-				runtime.stageSnapshot.startedAt === undefined &&
-				!input.hasScopedParents
-			) {
-				const actualParentIds = runtime.scheduler.tracker.currentParents();
-				const sameParents =
-					actualParentIds.length === runtime.stageSnapshot.parentIds.length &&
-					actualParentIds.every((value) => runtime.stageSnapshot.parentIds.includes(value));
-				if (!sameParents) {
-					runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
-					refreshedParentIds = actualParentIds;
-				}
-			}
-			if (trackStageLifecycle) {
-				const now = Date.now();
-				const hasNoExplicitModelConfig =
-					input.options?.model === undefined && input.options?.fallbackModels === undefined;
-				const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
-				if (
-					callOptions.eagerSession &&
-					!promptAdapterHandlesInitialPrompt &&
-					(hasNoExplicitModelConfig ||
-						(await hasExplicitFastModeCandidate({
-							model: input.options?.model,
-							fallbackModels: input.options?.fallbackModels,
-							models: runtime.opts.models,
-						})))
-				) {
-					try {
-						await runtime.innerCtx.__ensureSession();
-					} catch (err) {
-						if (!(err instanceof Error && err.message.includes("prompt adapter not configured"))) throw err;
-					}
-				}
-				if (refreshedParentIds !== undefined) {
-					runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
-				}
-				runtime.stageSnapshot.status = "running";
-				runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
-				runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-				// Publish every graph-visible live write before this task can yield.
-				runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
-				runtime.appendStageStartOnce();
-				const sessionMeta = runtime.innerCtx.__sessionMeta();
-				if (sessionMeta.sessionId !== undefined || sessionMeta.sessionFile !== undefined) {
-					await runtime.captureStageSessionMeta({ awaitDurable: true });
-				}
-				runtime.startStageSessionHeartbeat();
-			} else {
-				runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-			}
-
-			runtime.mcpScope.apply();
-
-			const abortSession = (): void => {
-				void runtime.innerCtx.abort().catch(() => {});
-			};
-			if (runtime.signal.aborted) abortSession();
-			else runtime.signal.addEventListener("abort", abortSession, { once: true });
-			let result: T;
-			try {
-				runtime.state.askUserQuestionObservedThisTurn = false;
-				runtime.state.chatAnswerObservedThisTurn = false;
-				result = await runtime.raceStageSessionHeartbeat(raceAbort(call(), runtime.signal));
-				if (runtime.budget.enabled && typeof result === "string") stageResultBeforeBudget = result;
-				const initialDrain = await drainResumeContinuations(result);
-				result = initialDrain.result;
-				if (runtime.budget.enabled && typeof result === "string") stageResultBeforeBudget = result;
-				let repeatReadinessAfterChatTurn = initialDrain.chatAnswerObserved;
-
-				if (
-					!runtime.signal.aborted &&
-					readinessGateEnabled &&
-					(runtime.state.askUserQuestionObservedThisTurn || repeatReadinessAfterChatTurn) &&
-					!runtime.innerCtx.__structuredOutputFinalized()
-				) {
-					let resolveNextTurnEnd: (() => void) | null = null;
-					const unsubscribeTurnWatcher = runtime.innerCtx.subscribe((event) => {
-						if ((event as { type?: unknown }).type === "agent_end" && resolveNextTurnEnd) {
-							const resolve = resolveNextTurnEnd;
-							resolveNextTurnEnd = null;
-							resolve();
-						}
-					});
-					try {
-						while (runtime.state.askUserQuestionObservedThisTurn || repeatReadinessAfterChatTurn) {
-							const decision = await confirmReadiness();
-							if (decision.action === "advance") break;
-							if (runtime.signal.aborted) break;
-							runtime.state.askUserQuestionObservedThisTurn = false;
-							runtime.state.chatAnswerObservedThisTurn = false;
-							if (decision.message !== undefined) {
-								result = (await runtime.raceStageSessionHeartbeat(
-									raceAbort(runtime.innerCtx.prompt(decision.message), runtime.signal),
-								)) as T;
-								if (runtime.budget.enabled && typeof result === "string") stageResultBeforeBudget = result;
-							} else {
-								runtime.state.waitingForStageChatTurn = true;
-								try {
-									await runtime.raceStageSessionHeartbeat(
-										raceAbort(
-											new Promise<void>((resolve) => {
-												resolveNextTurnEnd = resolve;
-												runtime.state.wakeWaitingForStageChatTurn = resolve;
-											}),
-											runtime.signal,
-										),
-									);
-								} finally {
-									runtime.state.wakeWaitingForStageChatTurn = undefined;
-									runtime.state.waitingForStageChatTurn = false;
-								}
-								if (runtime.signal.aborted) break;
-								const responseText = runtime.innerCtx.__getLastAssistantText();
-								if (responseText !== undefined) {
-									result = responseText as T;
-									if (runtime.budget.enabled) stageResultBeforeBudget = responseText;
-								}
-							}
-							const continuationDrain = await drainResumeContinuations(result);
-							result = continuationDrain.result;
-							if (runtime.budget.enabled && typeof result === "string") stageResultBeforeBudget = result;
-							repeatReadinessAfterChatTurn ||= continuationDrain.chatAnswerObserved;
-							if (runtime.innerCtx.__structuredOutputFinalized()) break;
-						}
-					} finally {
-						runtime.state.wakeWaitingForStageChatTurn = undefined;
-						resolveNextTurnEnd = null;
-						unsubscribeTurnWatcher();
-					}
-				}
-			} finally {
-				runtime.signal.removeEventListener("abort", abortSession);
-			}
-			if (runtime.budget.enabled) stageResultBeforeBudget ??= runtime.innerCtx.__getLastAssistantText();
-			runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-			const afterBudget = runtime.budget.checkpoint(runtime.name);
-			if (afterBudget.kind === "wrap_up") await runtime.budget.deliverWrapUp(runtime.name);
-			if (afterBudget.kind === "exhausted" && runtime.budget.enabled)
-				await runtime.budget.stopAtBoundaryAsync(runtime.name);
-			await runtime.innerCtx.__closeGeneration();
-			await runtime.captureStageSessionMeta({ awaitDurable: true });
-			if (
-				trackStageLifecycle &&
-				runtime.stageFailFastScope?.failed === true &&
-				runtime.stageFailFastScope.activeStages.has(runtime.stageId)
-			) {
-				runtime.markSkippedForParallelFailFast();
-				throw runtime.parallelFailFastError();
-			}
-			if (trackStageLifecycle && runtime.state.stageFinalized) throw runtime.parallelFailFastError();
-			if (trackStageLifecycle) {
-				const assistantText = runtime.budget.enabled
-					? (stageResultBeforeBudget ?? runtime.innerCtx.__getLastAssistantText())
-					: runtime.innerCtx.__getLastAssistantText();
-				terminalStateIsSuccess = true;
-				applyTerminalStageState = () => {
-					runtime.stageSnapshot.status = "completed";
-					if (assistantText !== undefined) runtime.stageSnapshot.result = assistantText;
-				};
-			}
-			return result;
-		} catch (err) {
-			const workflowExitAbort = runtime.signal.aborted ? runtime.exit.currentWorkflowExitAbortReason() : undefined;
-			const budgetError = err instanceof WorkflowBudgetExceededError ? err : undefined;
-			if (budgetError !== undefined && trackStageLifecycle && !runtime.state.skippedForParallelFailFast) {
-				let selectedBudgetError = budgetError;
-				if (
-					runtime.activeStore.runs().find((run) => run.id === runtime.runId)?.budgetState?.wrapUpCompleted !== true
-				) {
-					try {
-						await runtime.budget.deliverWrapUp(runtime.name);
-					} catch (wrapUpError) {
-						if (wrapUpError instanceof WorkflowBudgetExceededError) selectedBudgetError = wrapUpError;
-					}
-				}
-				applyTerminalStageState = () => {
-					if (stageResultBeforeBudget !== undefined) {
-						runtime.stageSnapshot.status = "completed";
-						runtime.stageSnapshot.result = stageResultBeforeBudget;
-					} else {
-						runtime.stageSnapshot.status = "failed";
-						runtime.stageSnapshot.error = selectedBudgetError.message;
-					}
-				};
-				throw selectedBudgetError;
-			} else if (workflowExitAbort !== undefined && !runtime.state.skippedForParallelFailFast) {
-				runtime.state.stageClosedByWorkflowExit = true;
-				if (trackStageLifecycle && !isTerminalStage(runtime.stageSnapshot)) {
-					const skippedReason = runtime.exit.workflowExitSkippedReason(workflowExitAbort.reason);
-					applyTerminalStageState = () => {
-						runtime.stageSnapshot.status = "skipped";
-						runtime.stageSnapshot.skippedReason = skippedReason;
-					};
-				}
-			} else if (trackStageLifecycle && !runtime.signal.aborted && !runtime.state.skippedForParallelFailFast) {
-				const failure = runtime.classifyExecutorFailure(err);
-				applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
-			}
-			throw err;
-		} finally {
-			unregisterBudgetWrapUp();
-			// Finalization, handle release, and limiter release are each independent.
-			// If finalizeStageSnapshot() throws, the limiter must still be released
-			// so the concurrency semaphore is not leaked.
-			// cross-ref: issue #1498 — durable finalization failures must not leak the stage limiter.
-			let finalizationError: { readonly thrown: true; readonly error: unknown } | undefined;
-			// Tracked separately from `finalizationError`: only a failed final durable
-			// checkpoint may rewrite an otherwise-successful terminal stage state.
-			let durableCheckpointError: { readonly thrown: true; readonly error: unknown } | undefined;
-			try {
-				runtime.mcpScope.clear();
-			} catch (err) {
-				finalizationError = { thrown: true, error: err };
-			}
-			try {
-				// Drain rather than stop: a checkpoint still in flight must be awaited
-				// here, or its late rejection is discarded with the cancelled timer.
-				await runtime.drainStageSessionHeartbeat();
-			} catch (err) {
-				durableCheckpointError = { thrown: true, error: err };
-			}
-			try {
-				await runtime.innerCtx.__closeGeneration();
-				await runtime.captureStageSessionMeta({ awaitDurable: true });
-			} catch (err) {
-				durableCheckpointError ??= { thrown: true, error: err };
-			}
-			finalizationError ??= durableCheckpointError;
-			if (trackStageLifecycle) {
-				// A stage whose final durability checkpoint failed must never be
-				// persisted as `completed` while its caller receives that rejection.
-				if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
-					const failure = runtime.classifyExecutorFailure(durableCheckpointError.error);
-					applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
-				}
-				if (!runtime.state.stageFinalized) applyTerminalStageState?.();
-				// `finalizeStageSnapshot` calls the version-bumping `recordStageEnd`
-				// before its first yield, so the live write cannot outpace the cache.
-				try {
-					await runtime.finalizeStageSnapshot();
-				} catch (err) {
-					finalizationError ??= { thrown: true, error: err };
-				}
-				try {
-					if (
-						runtime.state.stageClosedByWorkflowExit ||
-						runtime.exit.currentWorkflowExitAbortReason() !== undefined
-					) {
-						await runtime.releaseLiveHandle().catch(() => {});
-					} else {
-						await runtime.dropStageControlForCompletion().catch(() => {});
-					}
-				} catch {
-					// Best-effort: handle release failure must not prevent limiter release.
-				}
-			} else if (
-				runtime.state.stageClosedByWorkflowExit ||
-				runtime.exit.currentWorkflowExitAbortReason() !== undefined
-			) {
-				await runtime.releaseLiveHandle().catch(() => {});
-			}
-			input.limiter.release();
-			if (finalizationError !== undefined) throwFinalizationError(finalizationError.error);
-		}
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/executor-stage-context.ts

@@ -1,153 +0,0 @@
-import type { TrackedStageCaller } from "./executor-stage-call.js";
-import type { LiveStageRuntime, StageContextWithMeta, StageNoticeInput } from "./executor-stage-types.js";
-import type { InternalStageContext } from "./stage-runner.js";
-
-function noticeValue(value: unknown): string {
-	if (typeof value === "string") return value;
-	if (value === undefined || value === null) return "";
-	if (typeof value === "object") {
-		const candidate = value as { id?: unknown; name?: unknown; label?: unknown };
-		if (typeof candidate.id === "string") return candidate.id;
-		if (typeof candidate.name === "string") return candidate.name;
-		if (typeof candidate.label === "string") return candidate.label;
-	}
-	return String(value);
-}
-
-function compactionMeta(result: unknown): string | undefined {
-	if (result === undefined || result === null || typeof result !== "object") return undefined;
-	const compaction = result as {
-		stats?: { tokensBefore?: unknown; tokensAfter?: unknown };
-		tokensBefore?: unknown;
-		tokensAfter?: unknown;
-		tokensKept?: unknown;
-	};
-	const beforeRaw = compaction.stats?.tokensBefore ?? compaction.tokensBefore;
-	const keptRaw = compaction.stats?.tokensAfter ?? compaction.tokensKept ?? compaction.tokensAfter;
-	const before = typeof beforeRaw === "number" ? beforeRaw : undefined;
-	const kept = typeof keptRaw === "number" ? keptRaw : undefined;
-	if (before === undefined || kept === undefined) return undefined;
-	return `${(before / 1000).toFixed(1)}k → ${(kept / 1000).toFixed(1)}k`;
-}
-
-export function createStageContext(input: {
-	readonly runtime: LiveStageRuntime;
-	readonly runTrackedStageCall: TrackedStageCaller;
-}): StageContextWithMeta {
-	const { runtime } = input;
-	const recordStageNotice = (notice: StageNoticeInput): void => {
-		runtime.activeStore.recordStageNotice(runtime.runId, runtime.stageId, {
-			id: crypto.randomUUID(),
-			ts: Date.now(),
-			...notice,
-		});
-	};
-
-	const innerCtx: InternalStageContext = runtime.innerCtx;
-	const sendStreamingUserMessage: InternalStageContext["sendUserMessage"] = async (text, options) => {
-		runtime.mcpScope.apply();
-		try {
-			await innerCtx.sendUserMessage(text, options);
-		} finally {
-			try {
-				runtime.mcpScope.clear();
-			} finally {
-				void runtime.captureStageSessionMeta();
-				runtime.applyModelFallbackMeta(innerCtx.__modelFallbackMeta());
-			}
-		}
-	};
-	return {
-		name: innerCtx.name,
-		prompt: (text, promptOptions) => {
-			runtime.throwIfStageMutationBlocked();
-			return input.runTrackedStageCall(() => innerCtx.prompt(text, promptOptions), true);
-		},
-		complete: (text, completeOptions) => {
-			runtime.throwIfStageMutationBlocked();
-			return input.runTrackedStageCall(() => innerCtx.complete(text, completeOptions));
-		},
-		sendUserMessage: (text, options) => {
-			runtime.throwIfStageMutationBlocked();
-			if (innerCtx.isStreaming) return sendStreamingUserMessage(text, options);
-			return input.runTrackedStageCall(() => innerCtx.sendUserMessage(text, options), { allowFinalized: true });
-		},
-		steer: (text) => {
-			runtime.throwIfStageMutationBlocked();
-			return innerCtx.steer(text);
-		},
-		followUp: (text) => {
-			runtime.throwIfStageMutationBlocked();
-			return innerCtx.followUp(text);
-		},
-		subscribe: (listener) => innerCtx.subscribe(listener),
-		get sessionFile() {
-			return innerCtx.sessionFile;
-		},
-		get sessionId() {
-			return innerCtx.sessionId;
-		},
-		setModel: async (model) => {
-			runtime.throwIfStageMutationBlocked();
-			await innerCtx.__ensureSession();
-			runtime.throwIfStageMutationBlocked();
-			recordStageNotice({ kind: "model", from: noticeValue(innerCtx.model), to: noticeValue(model) });
-			await innerCtx.setModel(model);
-		},
-		setThinkingLevel: (level) => {
-			runtime.throwIfStageMutationBlocked();
-			recordStageNotice({ kind: "thinking", from: noticeValue(innerCtx.thinkingLevel), to: noticeValue(level) });
-			innerCtx.setThinkingLevel(level);
-		},
-		cycleModel: async () => {
-			runtime.throwIfStageMutationBlocked();
-			const from = noticeValue(innerCtx.model);
-			const result = await innerCtx.cycleModel();
-			recordStageNotice({ kind: "model", from, to: noticeValue(innerCtx.model) });
-			return result;
-		},
-		cycleThinkingLevel: () => {
-			runtime.throwIfStageMutationBlocked();
-			const from = noticeValue(innerCtx.thinkingLevel);
-			const result = innerCtx.cycleThinkingLevel();
-			recordStageNotice({ kind: "thinking", from, to: noticeValue(innerCtx.thinkingLevel) });
-			return result;
-		},
-		get agent() {
-			return innerCtx.agent;
-		},
-		get model() {
-			return innerCtx.model;
-		},
-		get thinkingLevel() {
-			return innerCtx.thinkingLevel;
-		},
-		get messages() {
-			return innerCtx.messages;
-		},
-		get isStreaming() {
-			return innerCtx.isStreaming;
-		},
-		navigateTree: async (targetId, treeOptions) => {
-			runtime.throwIfStageMutationBlocked();
-			recordStageNotice({ kind: "tree", to: targetId });
-			return innerCtx.navigateTree(targetId, treeOptions);
-		},
-		compact: async () => {
-			runtime.throwIfStageMutationBlocked();
-			const result = await innerCtx.compact();
-			recordStageNotice({ kind: "compaction", to: "compacted", meta: compactionMeta(result) });
-			return result;
-		},
-		abortCompaction: () => {
-			runtime.throwIfStageMutationBlocked();
-			innerCtx.abortCompaction();
-		},
-		abort: async () => {
-			runtime.throwIfStageMutationBlocked();
-			recordStageNotice({ kind: "abort", to: "interrupted" });
-			await innerCtx.abort();
-		},
-		__modelFallbackMeta: () => innerCtx.__modelFallbackMeta(),
-	};
-}