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

package/dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts

@@ -1,278 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import type { AgentSession, PromptOptions } from "@bastani/atomic";
-import type { StageOutputOptions, StagePromptOptions, WorkflowMaxOutput } from "../../shared/types.js";
-import { ensureWorkflowArtifactRunDirectory, workflowArtifactRunPath } from "../../shared/workflow-artifacts.js";
-
-const DEFAULT_MAX_OUTPUT_BYTES = 200 * 1024;
-const DEFAULT_MAX_OUTPUT_LINES = 5000;
-
-type TranscriptContentBlock = {
-	readonly type?: string;
-	readonly text?: string;
-	readonly name?: string;
-	readonly id?: string;
-};
-
-type TranscriptMessage = {
-	readonly role?: string;
-	readonly content?: string | readonly TranscriptContentBlock[];
-	readonly customType?: string;
-	readonly stageAdmissionKey?: string;
-	readonly toolCallId?: string;
-	readonly toolName?: string;
-};
-
-function normalizeMaxOutput(maxOutput: WorkflowMaxOutput | undefined): Required<WorkflowMaxOutput> {
-	return {
-		bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
-		lines: maxOutput?.lines ?? DEFAULT_MAX_OUTPUT_LINES,
-	};
-}
-
-function truncateByLines(text: string, maxLines: number): { text: string; truncated: boolean } {
-	if (!Number.isFinite(maxLines) || maxLines <= 0) return { text: "", truncated: text.length > 0 };
-	const lines = text.split(/\r?\n/);
-	if (lines.length <= maxLines) return { text, truncated: false };
-	return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
-}
-
-function truncateByBytes(text: string, maxBytes: number): { text: string; truncated: boolean } {
-	if (!Number.isFinite(maxBytes) || maxBytes <= 0) return { text: "", truncated: text.length > 0 };
-	if (Buffer.byteLength(text, "utf8") <= maxBytes) return { text, truncated: false };
-
-	let low = 0;
-	let high = text.length;
-	while (low < high) {
-		const mid = Math.ceil((low + high) / 2);
-		if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
-		else high = mid - 1;
-	}
-	return { text: text.slice(0, low), truncated: true };
-}
-
-function truncateOutput(text: string, maxOutput: WorkflowMaxOutput | undefined): string {
-	const limits = normalizeMaxOutput(maxOutput);
-	const byLines = truncateByLines(text, limits.lines);
-	const byBytes = truncateByBytes(byLines.text, limits.bytes);
-	if (!byLines.truncated && !byBytes.truncated) return text;
-	return `${byBytes.text}\n\n[workflow output truncated; limits: ${limits.bytes} bytes, ${limits.lines} lines]`;
-}
-
-function countLines(text: string): number {
-	if (!text) return 0;
-	const newlineMatches = text.match(/\r\n|\r|\n/g);
-	return (newlineMatches?.length ?? 0) + (text.endsWith("\n") || text.endsWith("\r") ? 0 : 1);
-}
-
-function formatByteSize(bytes: number): string {
-	if (bytes < 1024) return `${bytes} B`;
-	const units = ["KB", "MB", "GB", "TB"];
-	let value = bytes / 1024;
-	let unitIndex = 0;
-	while (value >= 1024 && unitIndex < units.length - 1) {
-		value /= 1024;
-		unitIndex += 1;
-	}
-	return `${value.toFixed(1)} ${units[unitIndex]}`;
-}
-
-function transcriptPath(runId: string, outputPath: string): string {
-	const digest = createHash("sha256").update(outputPath).digest("hex").slice(0, 16);
-	return join(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename(outputPath)}.transcript.md`);
-}
-
-function appendContent(lines: string[], content: TranscriptMessage["content"]): void {
-	if (typeof content === "string") {
-		lines.push(content);
-		return;
-	}
-	if (!Array.isArray(content)) return;
-	for (const block of content) {
-		if (block.type === "text" && typeof block.text === "string") {
-			lines.push(block.text);
-			continue;
-		}
-		const serialized = JSON.stringify(block);
-		if (serialized !== undefined) lines.push(serialized);
-	}
-}
-
-function renderTranscript(messages: AgentSession["messages"] | undefined, fallbackOutput: string): string {
-	const lines = ["# Workflow stage transcript", ""];
-	for (const [index, message] of (messages ?? []).entries()) {
-		const record = message as TranscriptMessage;
-		const role = typeof record.role === "string" ? record.role : "message";
-		lines.push(`## ${index + 1} ${role}`);
-		if (typeof record.customType === "string") lines.push(`customType: ${record.customType}`);
-		if (typeof record.stageAdmissionKey === "string") lines.push(`stageAdmissionKey: ${record.stageAdmissionKey}`);
-		if (typeof record.toolName === "string") lines.push(`toolName: ${record.toolName}`);
-		if (typeof record.toolCallId === "string") lines.push(`toolCallId: ${record.toolCallId}`);
-		appendContent(lines, record.content);
-		lines.push("");
-	}
-	if ((messages?.length ?? 0) === 0) {
-		lines.push("## 1 assistant");
-		lines.push(fallbackOutput);
-		lines.push("");
-	}
-	return lines.join("\n");
-}
-
-function savedOutputReference(
-	outputPath: string,
-	fullOutput: string,
-	transcriptPathValue: string,
-	transcriptText: string,
-	transcriptAvailable: boolean,
-	warning?: string,
-): string {
-	const absolutePath = resolve(outputPath);
-	const bytes = Buffer.byteLength(fullOutput, "utf8");
-	const lines = countLines(fullOutput);
-	const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
-	const transcriptLines = countLines(transcriptText);
-	const outputReference = `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`;
-	const transcriptReference = transcriptAvailable
-		? `Transcript saved to: ${transcriptPathValue} (${formatByteSize(transcriptBytes)}, ${transcriptLines} ${transcriptLines === 1 ? "line" : "lines"}). Search it with rg, read narrow line ranges, and do not read it whole.`
-		: `Transcript unavailable at: ${transcriptPathValue}. Search it with rg when it becomes available, read narrow line ranges, and do not read it whole.`;
-	return [outputReference, transcriptReference, warning]
-		.filter((line): line is string => line !== undefined)
-		.join("\n");
-}
-
-function resolveOutputPath(
-	output: string | false | undefined,
-	runtimeCwd: string,
-	requestedCwd: string | undefined,
-): string | undefined {
-	if (typeof output !== "string" || output.length === 0) return undefined;
-	if (isAbsolute(output)) return output;
-	const baseCwd =
-		requestedCwd === undefined
-			? runtimeCwd
-			: isAbsolute(requestedCwd)
-				? requestedCwd
-				: resolve(runtimeCwd, requestedCwd);
-	return resolve(baseCwd, output);
-}
-
-/**
- * Report only what can be observed, never what the text appears to mean.
- *
- * An empty artifact is a fact. Whether a non-empty artifact is "really" a
- * pointer, an acknowledgement, or a deliverable is an inference this code
- * cannot make, so it does not try: the companion transcript named in every
- * receipt is the recovery path for anything that looks wrong to a reader.
- */
-function degenerateWarning(fullOutput: string): string | undefined {
-	return fullOutput.trim().length === 0
-		? "WARNING: the stage artifact is empty; search the companion transcript for this stage's work."
-		: undefined;
-}
-export function splitPromptOptions(options: StagePromptOptions | undefined): {
-	sdkOptions: PromptOptions | undefined;
-	outputOptions: StageOutputOptions;
-} {
-	if (!options) return { sdkOptions: undefined, outputOptions: {} };
-	const sdkOptions: PromptOptions = {};
-	if (options.expandPromptTemplates !== undefined) sdkOptions.expandPromptTemplates = options.expandPromptTemplates;
-	if (options.images !== undefined) sdkOptions.images = options.images;
-	if (options.streamingBehavior !== undefined) sdkOptions.streamingBehavior = options.streamingBehavior;
-	if (options.source !== undefined) sdkOptions.source = options.source;
-	if (options.preflightResult !== undefined) sdkOptions.preflightResult = options.preflightResult;
-
-	const outputOptions: StageOutputOptions = {
-		...(options.output !== undefined ? { output: options.output } : {}),
-		...(options.outputMode !== undefined ? { outputMode: options.outputMode } : {}),
-		...(options.context !== undefined ? { context: options.context } : {}),
-		...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
-		...(options.maxOutput !== undefined ? { maxOutput: options.maxOutput } : {}),
-		...(options.artifacts !== undefined ? { artifacts: options.artifacts } : {}),
-		...(options.sessionDir !== undefined ? { sessionDir: options.sessionDir } : {}),
-	};
-
-	return {
-		sdkOptions: Object.keys(sdkOptions).length === 0 ? undefined : sdkOptions,
-		outputOptions,
-	};
-}
-
-export function validatePromptOutputOptions(outputOptions: StageOutputOptions): void {
-	if (
-		outputOptions.outputMode === "file-only" &&
-		(typeof outputOptions.output !== "string" || outputOptions.output.length === 0)
-	) {
-		throw new Error(
-			'atomic-workflows: prompt sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".',
-		);
-	}
-}
-
-/**
- * Instruction appended to any prompt whose stage configures `output:`.
- *
- * The runtime owns the artifact write, so the prompt author should not have to
- * describe that plumbing — or remember to. Without this, a stage can end with
- * "done, see the file" and persist that sentence as its deliverable, which is a
- * foot-gun the workflow definition cannot see.
- */
-export function stageOutputInstruction(outputOptions: StageOutputOptions, hasStructuredOutput = false): string {
-	if (typeof outputOptions.output !== "string" || outputOptions.output.length === 0) return "";
-	if (hasStructuredOutput) {
-		return "\n\n[This stage has two final output channels. In the same final assistant message, write the complete human-readable artifact as ordinary assistant text before calling structured_output. That text is saved verbatim as the artifact and is what later stages read; the structured_output tool arguments are the machine-readable result for workflow logic. Do not replace the artifact text with JSON or a pointer to another file. Files you write yourself are not the artifact.]";
-	}
-	return "\n\n[This stage's final message is saved verbatim as its artifact and is what later stages read. Return the complete result in that message rather than a pointer to it. Files you write yourself are not the artifact.]";
-}
-
-export async function finalizePromptOutput(
-	fullOutput: string,
-	outputOptions: StageOutputOptions,
-	runtimeCwd: string,
-	runId: string,
-	messages?: AgentSession["messages"],
-): Promise<string> {
-	const outputPath = resolveOutputPath(outputOptions.output, runtimeCwd, outputOptions.cwd);
-	validatePromptOutputOptions(outputOptions);
-	const displayOutput = truncateOutput(fullOutput, outputOptions.maxOutput);
-	if (outputPath === undefined) return displayOutput;
-
-	const transcriptFile = transcriptPath(runId, outputPath);
-	const transcript = renderTranscript(messages, fullOutput);
-	try {
-		await mkdir(dirname(outputPath), { recursive: true });
-		await writeFile(outputPath, fullOutput, "utf8");
-	} catch (err) {
-		return `${displayOutput}\n\nOutput file error: ${outputPath}\n${err instanceof Error ? err.message : String(err)}`;
-	}
-	let transcriptAvailable = false;
-	let transcriptError: string | undefined;
-	try {
-		await ensureWorkflowArtifactRunDirectory(runId);
-		await mkdir(dirname(transcriptFile), { recursive: true });
-		await writeFile(transcriptFile, transcript, "utf8");
-		transcriptAvailable = true;
-	} catch (err) {
-		transcriptError = err instanceof Error ? err.message : String(err);
-	}
-
-	const warning =
-		[
-			transcriptError === undefined
-				? undefined
-				: `WARNING: companion transcript unavailable at ${transcriptFile}: ${transcriptError}`,
-			degenerateWarning(fullOutput),
-		]
-			.filter((line): line is string => line !== undefined)
-			.join("\n") || undefined;
-	const reference = savedOutputReference(
-		outputPath,
-		fullOutput,
-		transcriptFile,
-		transcript,
-		transcriptAvailable,
-		warning,
-	);
-	return outputOptions.outputMode === "file-only" ? reference : `${displayOutput}\n\n${reference}`;
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-pause.ts

@@ -1,206 +0,0 @@
-import type { StageSessionRuntime } from "./stage-runner-types.js";
-
-export interface StageSessionPauseResumeResult {
-	readonly releasedQueuedMessages: boolean;
-	/** True when a runner-admitted public delivery owns the first resumed turn. */
-	readonly runnerOwnedDeliveryPending: boolean;
-}
-
-interface PauseResumeResolution extends StageSessionPauseResumeResult {
-	readonly message?: string;
-	/** Lets the interrupted objective settle only after accepted public turns. */
-	readonly runnerOwnedDeliverySettlement: Promise<void>;
-}
-
-interface NativeQueuePauseControl {
-	readonly queuedMessagesPaused?: boolean;
-	pauseQueuedMessages(): void;
-	resumeQueuedMessages(beforeRelease?: () => void): boolean | Promise<boolean>;
-}
-
-function nativeQueuePauseControl(session: StageSessionRuntime | undefined): NativeQueuePauseControl | undefined {
-	if (typeof session?.pauseQueuedMessages !== "function" || typeof session.resumeQueuedMessages !== "function")
-		return undefined;
-	return session as StageSessionRuntime & NativeQueuePauseControl;
-}
-
-interface PauseRequest {
-	readonly deferred: PromiseWithResolvers<PauseResumeResolution>;
-	readonly abortBoundary: PromiseWithResolvers<void>;
-	readonly runnerOwnedDeliveries: Set<Promise<void>>;
-	readonly nativeQueuePause?: NativeQueuePauseControl;
-	confirmed: boolean;
-	resumePromise?: Promise<StageSessionPauseResumeResult>;
-}
-
-type PauseRejection = Error | DOMException | string;
-
-/** Serializes controlled pause, abort settlement, and one explicit resume. */
-export class StageSessionPause {
-	private request: PauseRequest | null = null;
-
-	constructor(private readonly getSession: () => StageSessionRuntime | undefined) {}
-
-	currentResume(): Promise<PauseResumeResolution> | undefined {
-		return this.request?.deferred.promise;
-	}
-
-	isPaused(): boolean {
-		return this.request !== null;
-	}
-	isConfirmedPaused(): boolean {
-		return this.request?.confirmed === true;
-	}
-
-	async requestPause(): Promise<void> {
-		if (this.request) return this.request.abortBoundary.promise;
-		const session = this.getSession();
-		const nativeQueuePause = nativeQueuePauseControl(session);
-		const request: PauseRequest = {
-			deferred: Promise.withResolvers<PauseResumeResolution>(),
-			abortBoundary: Promise.withResolvers<void>(),
-			runnerOwnedDeliveries: new Set(),
-			confirmed: false,
-			...(nativeQueuePause === undefined ? {} : { nativeQueuePause }),
-		};
-		void request.deferred.promise.catch(() => {});
-		void request.abortBoundary.promise.catch(() => {});
-		this.request = request;
-		let failed = false;
-		try {
-			request.nativeQueuePause?.pauseQueuedMessages();
-			await session?.abort();
-			request.abortBoundary.resolve();
-			await request.abortBoundary.promise;
-			request.confirmed = true;
-		} catch (error) {
-			failed = true;
-			request.abortBoundary.reject(error);
-			request.deferred.reject(error);
-			await this.rollbackNativePause(request.nativeQueuePause);
-			throw error;
-		} finally {
-			if (failed && this.request === request) this.request = null;
-		}
-	}
-
-	private async rollbackNativePause(control: NativeQueuePauseControl | undefined): Promise<void> {
-		if (control === undefined) return;
-		try {
-			await control.resumeQueuedMessages();
-		} catch {
-			// AgentSession keeps a failed abort boundary closed until one release
-			// attempt observes it. Retry only when its public gate is still paused.
-			if (control.queuedMessagesPaused !== true) return;
-			try {
-				await control.resumeQueuedMessages();
-			} catch {
-				/* Preserve the pause/abort error. */
-			}
-		}
-	}
-
-	/**
-	 * Capture a public delivery accepted while this pause generation owns the
-	 * stage. It starts only after resume and stays visible to the interrupted
-	 * objective, so readiness continuation cannot race it.
-	 */
-	deferRunnerOwnedDelivery<T>(operation: () => Promise<T>): Promise<T> | undefined {
-		const request = this.request;
-		if (!request) return undefined;
-		const delivery = request.deferred.promise.then(operation);
-		const settlement = delivery.then(
-			() => undefined,
-			() => undefined,
-		);
-		request.runnerOwnedDeliveries.add(settlement);
-		void settlement.finally(() => request.runnerOwnedDeliveries.delete(settlement));
-		return delivery;
-	}
-
-	resume(
-		message?: string,
-		beforeResolve?: (result: StageSessionPauseResumeResult) => void,
-		beforeRelease?: () => void,
-	): Promise<StageSessionPauseResumeResult> {
-		const request = this.request;
-		if (!request) {
-			beforeRelease?.();
-			return Promise.resolve({ releasedQueuedMessages: false, runnerOwnedDeliveryPending: false });
-		}
-		if (request.resumePromise) return request.resumePromise;
-		request.resumePromise = this.completeResume(request, message, beforeResolve, beforeRelease);
-		return request.resumePromise;
-	}
-
-	reject(reason: PauseRejection): void {
-		const request = this.request;
-		if (!request) return;
-		this.request = null;
-		request.abortBoundary.reject(reason);
-		request.deferred.reject(reason);
-	}
-
-	private async completeResume(
-		request: PauseRequest,
-		message: string | undefined,
-		beforeResolve: ((result: StageSessionPauseResumeResult) => void) | undefined,
-		beforeRelease: (() => void) | undefined,
-	): Promise<StageSessionPauseResumeResult> {
-		try {
-			await request.abortBoundary.promise;
-		} catch (error) {
-			request.deferred.reject(error);
-			if (this.request === request) this.request = null;
-			throw error;
-		}
-
-		let releaseAdmitted = false;
-		const admitRelease = (): void => {
-			if (releaseAdmitted) return;
-			beforeRelease?.();
-			releaseAdmitted = true;
-		};
-		let releasedQueuedMessages: boolean;
-		try {
-			const nativeQueuePause = request.nativeQueuePause;
-			if (nativeQueuePause === undefined) {
-				admitRelease();
-				releasedQueuedMessages = false;
-			} else {
-				// Legacy adapters with no callback parameter linearize at invocation.
-				// Native Atomic sessions call this at their final synchronous release.
-				if (nativeQueuePause.resumeQueuedMessages.length === 0) admitRelease();
-				releasedQueuedMessages = await nativeQueuePause.resumeQueuedMessages(admitRelease);
-				admitRelease();
-			}
-		} catch (error) {
-			// Native release can fail transiently. Preserve this pause generation and
-			// its waiter/deliveries; only retire the failed attempt so explicit resume
-			// can retry the same native hold.
-			if (this.request === request) request.resumePromise = undefined;
-			throw error;
-		}
-
-		try {
-			const runnerOwnedDeliveries = [...request.runnerOwnedDeliveries];
-			const runnerOwnedDeliverySettlement = Promise.all(runnerOwnedDeliveries).then(() => undefined);
-			const result = {
-				releasedQueuedMessages,
-				runnerOwnedDeliveryPending: runnerOwnedDeliveries.length > 0,
-			};
-			beforeResolve?.(result);
-			request.deferred.resolve({
-				...result,
-				runnerOwnedDeliverySettlement,
-				...(message === undefined ? {} : { message }),
-			});
-			if (this.request === request) this.request = null;
-			return result;
-		} catch (error) {
-			request.deferred.reject(error);
-			if (this.request === request) this.request = null;
-			throw error;
-		}
-	}
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-replacement.ts

@@ -1,41 +0,0 @@
-import type { AgentSession } from "@bastani/atomic";
-import { asAgentSession, disposeStageSession } from "./stage-runner-session.js";
-import type { StageSessionRuntime } from "./stage-runner-types.js";
-
-/** Keeps detached completion ownership continuous while a fallback session is replaced. */
-export class StageSessionReplacement {
-	private previous: StageSessionRuntime | undefined;
-	private readonly cleanups = new Set<Promise<void>>();
-
-	retire(session: StageSessionRuntime | undefined): void {
-		this.previous = session;
-	}
-
-	adopt(session: StageSessionRuntime): void {
-		const previous = this.previous;
-		this.previous = undefined;
-		if (!previous) return;
-		const source = asAgentSession(previous) as
-			| (AgentSession & {
-					transferWorkflowStageDeliveriesTo?(target: AgentSession): void;
-			  })
-			| undefined;
-		const target = asAgentSession(session);
-		if (source && target) source.transferWorkflowStageDeliveriesTo?.(target);
-		const cleanup = this.disposeAfterIdle(previous);
-		this.cleanups.add(cleanup);
-		void cleanup.finally(() => this.cleanups.delete(cleanup)).catch(() => {});
-	}
-
-	async dispose(): Promise<void> {
-		const previous = this.previous;
-		this.previous = undefined;
-		await Promise.allSettled([...(previous ? [disposeStageSession(previous)] : []), ...this.cleanups]);
-	}
-
-	private async disposeAfterIdle(session: StageSessionRuntime): Promise<void> {
-		const agent = session.agent as { waitForIdle?: () => Promise<void> } | undefined;
-		if (typeof agent?.waitForIdle === "function") await agent.waitForIdle();
-		await disposeStageSession(session);
-	}
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-send-user-message.ts

@@ -1,134 +0,0 @@
-import type { StageSendUserMessageOptions, StageUserMessageContent } from "../../shared/types.js";
-import type { StageDeliveryActivity } from "./stage-delivery-activity.js";
-import type { StageMessageAdmission, StageMessageTurn } from "./stage-runner-message-admission.js";
-import type { StageSessionRuntime, StageUserMessageDeliveryAction } from "./stage-runner-types.js";
-
-interface PromptOwnershipObserver {
-	arm(): void;
-	observe(): void;
-	observeStreaming(): void;
-	settle(action?: StageUserMessageDeliveryAction): void;
-	dispose(): void;
-}
-
-function createLocalPromptOwnershipObserver(
-	session: StageSessionRuntime,
-	promptStarted: (() => void) | undefined,
-): PromptOwnershipObserver {
-	let armed = false;
-	let observed = false;
-	let unsubscribe: (() => void) | undefined;
-	const observe = (): void => {
-		if (observed) return;
-		observed = true;
-		unsubscribe?.();
-		unsubscribe = undefined;
-		promptStarted?.();
-	};
-	unsubscribe = session.subscribe((event) => {
-		if (armed && event.type === "agent_start") observe();
-	});
-	return {
-		arm() {
-			armed = true;
-		},
-		observe,
-		observeStreaming() {
-			if (session.isStreaming) observe();
-		},
-		settle() {},
-		dispose() {
-			unsubscribe?.();
-		},
-	};
-}
-
-function coordinatedPromptOwnershipObserver(turn: StageMessageTurn): PromptOwnershipObserver {
-	return {
-		arm: () => turn.arm(),
-		observe: () => turn.observe(),
-		observeStreaming: () => turn.observeStreaming(),
-		settle: (action) => turn.settle(action),
-		dispose() {},
-	};
-}
-
-function unsupportedContentError(): Error {
-	return new Error(
-		"atomic-workflows: this stage session adapter does not support non-string sendUserMessage content; provide a runtime sendUserMessage implementation for text/image blocks.",
-	);
-}
-
-export async function sendStageUserMessage(
-	activeSession: StageSessionRuntime,
-	content: StageUserMessageContent,
-	options?: StageSendUserMessageOptions,
-	beforeDelivery?: () => void,
-	promptStarted?: () => void,
-	admission?: StageMessageAdmission,
-	activity?: StageDeliveryActivity,
-): Promise<StageUserMessageDeliveryAction> {
-	const streaming = activeSession.isStreaming || admission?.isOwned(activeSession) === true;
-	const deliverAs = streaming ? (options?.deliverAs ?? "followUp") : options?.deliverAs;
-	if (activeSession.sendUserMessage !== undefined) {
-		beforeDelivery?.();
-		let reportedAction: StageUserMessageDeliveryAction | undefined;
-		const ownership = streaming
-			? undefined
-			: admission === undefined
-				? createLocalPromptOwnershipObserver(activeSession, promptStarted)
-				: coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
-		ownership?.arm();
-		// An admitted idle delivery owns the visible Working period from here until
-		// it settles; a streaming delivery joins a turn that already owns it.
-		const deliveryId = streaming ? undefined : activity?.start();
-		try {
-			const delivery = activeSession.sendUserMessage(content, {
-				...(deliverAs === undefined ? {} : { deliverAs }),
-				__workflowDelivery: {
-					promptStarted: ownership?.observe ?? promptStarted,
-					delivered(action) {
-						reportedAction = action;
-					},
-				},
-			});
-			ownership?.observeStreaming();
-			await delivery;
-			const action = reportedAction ?? (streaming ? (deliverAs ?? "followUp") : "prompt");
-			ownership?.settle(action);
-			return action;
-		} catch (error) {
-			ownership?.settle();
-			throw error;
-		} finally {
-			ownership?.dispose();
-			activity?.settle(deliveryId);
-		}
-	}
-	if (typeof content !== "string") throw unsupportedContentError();
-	beforeDelivery?.();
-	if (streaming) {
-		if (deliverAs === "steer") await activeSession.steer(content);
-		else await activeSession.followUp(content);
-		return deliverAs ?? "followUp";
-	}
-	const ownership =
-		admission === undefined
-			? createLocalPromptOwnershipObserver(activeSession, promptStarted)
-			: coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
-	ownership.arm();
-	const deliveryId = activity?.start();
-	try {
-		const turn = activeSession.prompt(content);
-		ownership.observeStreaming();
-		await turn;
-		ownership.settle("prompt");
-		return "prompt";
-	} catch (error) {
-		ownership.settle();
-		throw error;
-	} finally {
-		ownership.dispose();
-		activity?.settle(deliveryId);
-	}
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-session-options.ts

@@ -1,38 +0,0 @@
-import { type CreateAgentSessionOptions, SessionManager } from "@bastani/atomic";
-import type { StageOptions } from "../../shared/types.js";
-import type { WorkflowResolvedModelCandidate } from "../shared/model-fallback.js";
-
-interface StageSessionOptionsInput {
-	readonly effectiveStageOptions: StageOptions | undefined;
-	readonly candidate: WorkflowResolvedModelCandidate | undefined;
-	readonly restoreSavedModel?: boolean;
-	readonly reattachSessionFile: string | undefined;
-	readonly sharedModelRuntime: CreateAgentSessionOptions["modelRuntime"];
-}
-
-export function buildStageSessionOptions(input: StageSessionOptionsInput): StageOptions | undefined {
-	const options: StageOptions =
-		input.candidate === undefined
-			? { ...(input.effectiveStageOptions ?? {}) }
-			: {
-					...(input.effectiveStageOptions ?? {}),
-					model: input.candidate.value,
-					...(input.candidate.reasoningLevel !== undefined
-						? { thinkingLevel: input.candidate.reasoningLevel }
-						: {}),
-					fallbackModels: undefined,
-					fallbackThinkingLevels: undefined,
-				};
-	if (input.restoreSavedModel === true) delete options.model;
-
-	if (input.reattachSessionFile !== undefined && options.sessionManager === undefined) {
-		const cwd = options.cwd ?? process.cwd();
-		options.sessionManager = SessionManager.open(input.reattachSessionFile, options.sessionDir, cwd);
-		options.context = undefined;
-		options.forkFromSessionFile = undefined;
-	}
-	if (input.sharedModelRuntime !== undefined && options.modelRuntime === undefined) {
-		options.modelRuntime = input.sharedModelRuntime;
-	}
-	return Object.keys(options).length === 0 ? undefined : options;
-}