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

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

@@ -1,196 +0,0 @@
-import type { StageSessionRuntime, StageUserMessageDeliveryAction } from "./stage-runner-types.js";
-
-type TurnState = "starting" | "owned" | "terminal";
-
-type PublicTurnId = string | number;
-
-interface TurnGeneration {
-	readonly id: number;
-	state: TurnState;
-	publicStarted: boolean;
-	publicTurnId?: PublicTurnId;
-}
-
-export interface StageMessageTurn {
-	arm(): void;
-	observe(): void;
-	observeStreaming(): void;
-	settle(action?: StageUserMessageDeliveryAction): void;
-}
-
-export class StageMessageAdmission {
-	private tail: Promise<void> | undefined;
-	private session: StageSessionRuntime | undefined;
-	private observeStarting: (() => void) | undefined;
-	private unsubscribe: (() => void) | undefined;
-	private nextGeneration = 0;
-	private starting: TurnGeneration | undefined;
-	private owned: TurnGeneration | undefined;
-	private readonly startedGenerations: TurnGeneration[] = [];
-	private readonly replayedTurnIds = new Set<PublicTurnId>();
-
-	run<T>(operation: (release: () => void) => Promise<T>): Promise<T> {
-		const admission = this.acquire();
-		if (typeof admission === "function") return this.runAdmitted(operation, admission);
-		return admission.then((release) => this.runAdmitted(operation, release));
-	}
-
-	isOwned(session: StageSessionRuntime): boolean {
-		return this.session === session && this.owned?.state === "owned";
-	}
-
-	startTurn(session: StageSessionRuntime, release: () => void): StageMessageTurn {
-		this.bind(session);
-		const generation: TurnGeneration = {
-			id: ++this.nextGeneration,
-			state: "starting",
-			publicStarted: false,
-		};
-		let armed = false;
-		let settled = false;
-		const observe = (): void => {
-			if (!armed || settled || generation.state !== "starting" || this.starting !== generation) return;
-			generation.state = "owned";
-			this.starting = undefined;
-			this.observeStarting = undefined;
-			this.owned = generation;
-			release();
-		};
-		return {
-			arm: () => {
-				if (settled || armed) return;
-				armed = true;
-				this.starting = generation;
-				this.observeStarting = observe;
-			},
-			observe,
-			observeStreaming: () => {
-				if (session.isStreaming) observe();
-			},
-			settle: (action) => {
-				if (settled) return;
-				settled = true;
-				if (this.starting === generation) {
-					this.starting = undefined;
-					this.observeStarting = undefined;
-				}
-				if (generation.state === "starting") {
-					generation.state = "terminal";
-					this.releaseBindingIfIdle();
-					return;
-				}
-				if (generation.state !== "owned") {
-					this.releaseBindingIfIdle();
-					return;
-				}
-				generation.state = "terminal";
-				if (action === "handled") {
-					const queuedIndex = this.startedGenerations.findIndex((entry) => entry.id === generation.id);
-					if (queuedIndex >= 0) this.startedGenerations.splice(queuedIndex, 1);
-				}
-				if (this.owned === generation) this.owned = undefined;
-				this.releaseBindingIfIdle();
-			},
-		};
-	}
-
-	reset(): void {
-		this.unsubscribe?.();
-		this.unsubscribe = undefined;
-		this.session = undefined;
-		this.observeStarting = undefined;
-		this.starting = undefined;
-		this.owned = undefined;
-		this.startedGenerations.length = 0;
-		this.replayedTurnIds.clear();
-	}
-
-	dispose(): void {
-		this.reset();
-	}
-
-	private bind(session: StageSessionRuntime): void {
-		if (this.session === session) return;
-		this.reset();
-		this.session = session;
-		let subscribing = true;
-		this.unsubscribe = session.subscribe((event) => {
-			if (event.type === "agent_start") {
-				if (subscribing) this.recordReplayedStart(event.turnId);
-				else this.observePublicStart(event.turnId);
-				return;
-			}
-			if (event.type === "agent_end") this.endStartedTurn(event.turnId, !subscribing);
-		});
-		subscribing = false;
-	}
-
-	private recordReplayedStart(turnId: PublicTurnId | undefined): void {
-		// Untagged synchronous callbacks are snapshots only. Recording them would
-		// make a future current-turn end indistinguishable from an old replay end.
-		if (turnId !== undefined) this.replayedTurnIds.add(turnId);
-	}
-
-	private observePublicStart(turnId: PublicTurnId | undefined): void {
-		const generation = this.starting ?? this.owned;
-		if (generation === undefined || generation.state === "terminal") return;
-		this.observeStarting?.();
-		if (generation.publicStarted) return;
-		generation.publicStarted = true;
-		if (turnId !== undefined) {
-			this.replayedTurnIds.delete(turnId);
-			generation.publicTurnId = turnId;
-		}
-		this.startedGenerations.push(generation);
-	}
-
-	private endStartedTurn(turnId: PublicTurnId | undefined, releaseIfIdle = true): void {
-		if (turnId !== undefined && this.replayedTurnIds.delete(turnId)) {
-			if (releaseIfIdle) this.releaseBindingIfIdle();
-			return;
-		}
-		const generationIndex =
-			turnId === undefined
-				? this.startedGenerations.findIndex((entry) => entry.publicTurnId === undefined)
-				: this.startedGenerations.findIndex((entry) => entry.publicTurnId === turnId);
-		if (generationIndex < 0) return;
-		const [generation] = this.startedGenerations.splice(generationIndex, 1);
-		if (generation === undefined) return;
-		generation.state = "terminal";
-		if (this.owned === generation) this.owned = undefined;
-		if (releaseIfIdle) this.releaseBindingIfIdle();
-	}
-
-	private releaseBindingIfIdle(): void {
-		if (this.starting !== undefined || this.owned !== undefined || this.startedGenerations.length > 0) return;
-		this.unsubscribe?.();
-		this.unsubscribe = undefined;
-		this.session = undefined;
-		this.replayedTurnIds.clear();
-	}
-
-	private acquire(): (() => void) | Promise<() => void> {
-		const previous = this.tail;
-		const next = Promise.withResolvers<void>();
-		this.tail = next.promise;
-		const release = (): void => {
-			next.resolve();
-			if (this.tail === next.promise) this.tail = undefined;
-		};
-		return previous === undefined ? release : previous.then(() => release);
-	}
-
-	private async runAdmitted<T>(operation: (release: () => void) => Promise<T>, release: () => void): Promise<T> {
-		let released = false;
-		const releaseOnce = (): void => {
-			if (released) return;
-			released = true;
-			release();
-		};
-		try {
-			return await operation(releaseOnce);
-		} finally {
-			releaseOnce();
-		}
-	}
-}

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

@@ -1,177 +0,0 @@
-import type { AgentSession } from "@bastani/atomic";
-import { errorMessage } from "../shared/model-fallback.js";
-import type { StageSessionRuntime } from "./stage-runner-types.js";
-
-type TextLikeContent = {
-	readonly type?: string;
-	readonly text?: string;
-	readonly id?: string;
-	readonly name?: string;
-};
-
-type MessageWithTextContent = {
-	readonly content?: string | readonly TextLikeContent[];
-};
-
-export function extractMessageText(message: AgentSession["messages"][number]): string {
-	const { content } = message as MessageWithTextContent;
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) {
-		return content
-			.map((block) => (block.type === "text" && typeof block.text === "string" ? block.text : ""))
-			.filter(Boolean)
-			.join("");
-	}
-	return "";
-}
-
-export function lastAssistantTextFromMessages(messages: AgentSession["messages"]): string | undefined {
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "assistant") continue;
-		const text = extractMessageText(message).trim();
-		if (text) return text;
-	}
-	return undefined;
-}
-
-/**
- * Artifact text for a successful `structured_output` call (issue #2198).
- *
- * Primary: the ordinary text of the exact assistant message that carried the
- * successful tool call, so corrective attempts and later admitted turns cannot
- * replace the pairing. Fallback: when that message carries no ordinary text —
- * or the session no longer holds it after model-fallback recreation — the most
- * recent earlier assistant message that carries text and makes no
- * `structured_output` call. Assistant turns after the successful call never
- * win. When neither side exists the caller writes an empty artifact and its
- * receipt carries the standard empty-artifact warning; the companion
- * transcript remains the recovery path.
- */
-export function assistantArtifactTextForToolCall(
-	messages: AgentSession["messages"],
-	toolCallId: string,
-): string | undefined {
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "assistant") continue;
-		const { content } = message as MessageWithTextContent;
-		if (!Array.isArray(content)) continue;
-		if (!content.some((block) => block.type === "toolCall" && block.id === toolCallId)) continue;
-		const text = extractMessageText(message);
-		if (text.trim().length > 0) return text;
-		return lastNonStructuredAssistantTextBefore(messages, index);
-	}
-	return lastNonStructuredAssistantTextBefore(messages, messages.length);
-}
-
-function lastNonStructuredAssistantTextBefore(
-	messages: AgentSession["messages"],
-	endIndex: number,
-): string | undefined {
-	for (let index = endIndex - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "assistant") continue;
-		const { content } = message as MessageWithTextContent;
-		if (!Array.isArray(content)) continue;
-		if (content.some((block) => block.type === "toolCall" && block.name === "structured_output")) continue;
-		const text = extractMessageText(message);
-		if (text.trim().length > 0) return text;
-	}
-	return undefined;
-}
-
-function messageStopReason(message: AgentSession["messages"][number]): string | undefined {
-	const record = message as { readonly stopReason?: unknown };
-	return typeof record.stopReason === "string" ? record.stopReason : undefined;
-}
-
-function normalizedStopReason(stopReason: string | undefined): string | undefined {
-	return stopReason?.toLowerCase().replace(/[_-]+/g, "");
-}
-
-function isTerminalAssistantFailureStopReason(stopReason: string | undefined): boolean {
-	const normalized = normalizedStopReason(stopReason);
-	return normalized === "error" || normalized === "aborted";
-}
-
-function isCleanAssistantStopReason(stopReason: string | undefined): boolean {
-	const normalized = normalizedStopReason(stopReason);
-	return normalized === "stop" || normalized === "tooluse" || normalized === "length";
-}
-
-function assistantErrorMessage(message: AgentSession["messages"][number]): string | undefined {
-	const record = message as { readonly errorMessage?: unknown };
-	return typeof record.errorMessage === "string" && record.errorMessage.trim().length > 0
-		? record.errorMessage
-		: undefined;
-}
-
-export function latestTerminalAssistantFailureSince(
-	messages: AgentSession["messages"],
-	startIndex: number,
-): AgentSession["messages"][number] | undefined {
-	for (let index = messages.length - 1; index >= startIndex; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "assistant") continue;
-		const stopReason = messageStopReason(message);
-		if (isTerminalAssistantFailureStopReason(stopReason)) return message;
-		if (isCleanAssistantStopReason(stopReason)) return undefined;
-		if (assistantErrorMessage(message) === undefined && extractMessageText(message).trim().length > 0) {
-			return undefined;
-		}
-	}
-	return undefined;
-}
-
-export class WorkflowPromptModelFailure extends Error {
-	override readonly cause: unknown;
-
-	constructor(cause: unknown) {
-		super(errorMessage(cause));
-		this.name = "WorkflowPromptModelFailure";
-		this.cause = cause;
-	}
-}
-
-function terminatingToolResultText(
-	messages: AgentSession["messages"],
-	terminatingToolCallIds: ReadonlySet<string>,
-): string | undefined {
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (!message) continue;
-		if (message.role === "toolResult") {
-			const toolCallId = (message as { toolCallId?: unknown }).toolCallId;
-			if (typeof toolCallId !== "string" || !terminatingToolCallIds.has(toolCallId)) {
-				return undefined;
-			}
-			const text = extractMessageText(message).trim();
-			return text.length > 0 ? text : undefined;
-		}
-		if (message.role === "assistant") return undefined;
-	}
-	return undefined;
-}
-
-export function lastAssistantTextFromSession(
-	activeSession: StageSessionRuntime | undefined,
-	fallback: string | undefined,
-	terminatingToolCallIds: ReadonlySet<string>,
-): string | undefined {
-	if (!activeSession) return fallback;
-	const terminatingText = terminatingToolResultText(activeSession.messages, terminatingToolCallIds);
-	if (terminatingText !== undefined) return terminatingText;
-	const direct = activeSession.getLastAssistantText?.();
-	if (direct?.trim()) return direct;
-	return lastAssistantTextFromMessages(activeSession.messages) ?? direct ?? fallback;
-}
-
-export function assistantMessage(text: string): AgentSession["messages"] {
-	return [
-		{
-			role: "assistant",
-			content: [{ type: "text", text }],
-		},
-	] as AgentSession["messages"];
-}

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

@@ -1,97 +0,0 @@
-import { type CreateAgentSessionOptions, SessionManager } from "@bastani/atomic";
-import { resolveStageGroup, stageHasIntercomAccess } from "../../shared/intercom-group.js";
-import type { StageExecutionMeta, StageOptions } from "../../shared/types.js";
-import type { AgentSessionConsumer } from "./stage-runner-types.js";
-
-function workflowSessionOptions(meta: StageExecutionMeta) {
-	return {
-		internal: true as const,
-		workflow: { runId: meta.runId, stageId: meta.stageId, stageName: meta.stageName },
-	};
-}
-
-function workflowOrchestrationContext(
-	meta: StageExecutionMeta,
-	stageOptions: StageOptions | undefined,
-): NonNullable<CreateAgentSessionOptions["orchestrationContext"]> {
-	const base = {
-		kind: "workflow-stage" as const,
-		workflowRunId: meta.runId,
-		workflowStageId: meta.stageId,
-		workflowStageName: meta.stageName,
-		constraints: { disableWorkflowTool: true as const },
-	};
-	const intercomGroup = stageHasIntercomAccess(stageOptions)
-		? resolveStageGroup(stageOptions, meta.workflowIntercomGroup)
-		: undefined;
-	return intercomGroup ? { ...base, intercomGroup } : base;
-}
-
-export function stripWorkflowOnlyOptions(
-	options: StageOptions | undefined,
-	defaultSessionDir: string | undefined,
-	meta: StageExecutionMeta,
-): CreateAgentSessionOptions {
-	const classification = workflowSessionOptions(meta);
-	const orchestrationContext = workflowOrchestrationContext(meta, options);
-	if (!options) {
-		return defaultSessionDir === undefined
-			? { orchestrationContext }
-			: {
-					orchestrationContext,
-					sessionManager: SessionManager.create(process.cwd(), defaultSessionDir, classification),
-				};
-	}
-	const {
-		schema: _schema,
-		mcp: _mcp,
-		fallbackModels: _fallbackModels,
-		fallbackThinkingLevels: _fallbackThinkingLevels,
-		context,
-		forkFromSessionFile,
-		resumeFromSessionFile,
-		durableReplayKey: _durableReplayKey,
-		durableAccumulatedDurationMs: _durableAccumulatedDurationMs,
-		durableStageId: _durableStageId,
-		durableParentIds: _durableParentIds,
-		sessionDir,
-		gitWorktreeDir: _gitWorktreeDir,
-		baseBranch: _baseBranch,
-		group: _group,
-		...sessionOptions
-	} = options;
-	if (sessionOptions.sessionManager === undefined) {
-		const cwd = sessionOptions.cwd ?? process.cwd();
-		const effectiveSessionDir = sessionDir ?? defaultSessionDir;
-		if (resumeFromSessionFile !== undefined) {
-			sessionOptions.sessionManager = SessionManager.open(resumeFromSessionFile, effectiveSessionDir, cwd);
-		} else if (context === "fork" && forkFromSessionFile !== undefined) {
-			sessionOptions.sessionManager = SessionManager.forkFrom(
-				forkFromSessionFile,
-				cwd,
-				effectiveSessionDir,
-				classification,
-			);
-		} else if (effectiveSessionDir !== undefined) {
-			sessionOptions.sessionManager = SessionManager.create(cwd, effectiveSessionDir, classification);
-		}
-	}
-	return { ...sessionOptions, orchestrationContext } as CreateAgentSessionOptions;
-}
-
-export function missingAdapter(consumer: AgentSessionConsumer): never {
-	if (consumer === "complete") {
-		throw new Error(
-			"atomic-workflows: ctx.complete requires either RunOpts.adapters.complete or RunOpts.adapters.agentSession",
-		);
-	}
-	throw new Error(
-		"atomic-workflows: prompt adapter not configured — provide an AgentSessionAdapter via RunOpts.adapters.agentSession",
-	);
-}
-
-export function unavailableSync(property: string): never {
-	throw new Error(
-		`atomic-workflows: stage AgentSession property "${property}" is unavailable until the SDK session has been created`,
-	);
-}