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

package/dist/builtin/workflows/src/runs/shared/model-fallback-candidates.ts

@@ -1,325 +0,0 @@
-import type { CreateAgentSessionOptions } from "@bastani/atomic";
-import type {
-	WorkflowModelCatalogPort,
-	WorkflowModelInfo,
-	WorkflowModelValue,
-	WorkflowThinkingLevel,
-} from "../../shared/types.js";
-
-export interface WorkflowResolvedModelCandidate {
-	readonly id: string;
-	readonly value: WorkflowModelValue;
-	readonly reasoningLevel?: WorkflowThinkingLevel;
-}
-
-function makeCandidate(
-	id: string,
-	value: WorkflowModelValue,
-	level: WorkflowThinkingLevel | undefined,
-): WorkflowResolvedModelCandidate {
-	return {
-		id,
-		value,
-		...(level !== undefined ? { reasoningLevel: level } : {}),
-	};
-}
-
-const WORKFLOW_THINKING_LEVELS = [
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-] as const satisfies readonly WorkflowThinkingLevel[];
-const WORKFLOW_THINKING_LEVEL_SET: ReadonlySet<string> = new Set(WORKFLOW_THINKING_LEVELS);
-
-export function splitReasoningSuffix(model: string): {
-	readonly baseModel: string;
-	readonly level?: WorkflowThinkingLevel;
-} {
-	const index = model.lastIndexOf(":");
-	if (index < 0) return { baseModel: model };
-	const suffix = model.slice(index + 1);
-	if (WORKFLOW_THINKING_LEVEL_SET.has(suffix)) {
-		return { baseModel: model.slice(0, index), level: suffix as WorkflowThinkingLevel };
-	}
-	return { baseModel: model };
-}
-
-function candidateKey(candidate: WorkflowResolvedModelCandidate): string {
-	return `${candidate.id}::${candidate.reasoningLevel ?? ""}`;
-}
-
-interface ModelResolutionFailure {
-	readonly input: string;
-	readonly reason: string;
-}
-
-export class WorkflowModelValidationError extends Error {
-	readonly failures: readonly ModelResolutionFailure[];
-
-	constructor(failures: readonly ModelResolutionFailure[]) {
-		super(formatModelValidationError(failures));
-		this.name = "WorkflowModelValidationError";
-		this.failures = failures;
-	}
-}
-
-function formatModelValidationError(failures: readonly ModelResolutionFailure[]): string {
-	const lines = ["workflows: model validation failed before starting workflow.", "Unavailable or ambiguous models:"];
-	for (const failure of failures) {
-		lines.push(`- ${failure.input} (${failure.reason})`);
-	}
-	return lines.join("\n");
-}
-
-function isModelObject(value: WorkflowModelValue): value is NonNullable<CreateAgentSessionOptions["model"]> {
-	return typeof value !== "string";
-}
-
-export function workflowModelId(value: WorkflowModelValue | undefined): string | undefined {
-	if (value === undefined) return undefined;
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		return trimmed.length === 0 ? undefined : trimmed;
-	}
-	return `${String(value.provider)}/${value.id}`;
-}
-
-function normalizeInfo(info: WorkflowModelInfo): WorkflowModelInfo {
-	const fullId = info.fullId.trim().length > 0 ? info.fullId : `${info.provider}/${info.id}`;
-	return { ...info, fullId };
-}
-
-function uniqueByFullId(models: readonly WorkflowModelInfo[]): WorkflowModelInfo[] {
-	const seen = new Set<string>();
-	const result: WorkflowModelInfo[] = [];
-	for (const info of models.map(normalizeInfo)) {
-		if (seen.has(info.fullId)) continue;
-		seen.add(info.fullId);
-		result.push(info);
-	}
-	return result;
-}
-
-function resolveStringModel(
-	rawInput: string,
-	availableModels: readonly WorkflowModelInfo[] | undefined,
-	preferredProvider: string | undefined,
-): WorkflowResolvedModelCandidate | ModelResolutionFailure {
-	const input = rawInput.trim();
-	if (!input) return { input: rawInput, reason: "empty model id" };
-	const { baseModel, level } = splitReasoningSuffix(input);
-
-	const candidate = (id: string, value: WorkflowModelValue): WorkflowResolvedModelCandidate =>
-		makeCandidate(id, value, level);
-
-	if (availableModels === undefined) {
-		return candidate(baseModel, baseModel);
-	}
-
-	const models = uniqueByFullId(availableModels);
-	const explicit = models.find((model) => model.fullId === baseModel);
-	if (explicit !== undefined) {
-		return candidate(explicit.fullId, explicit.model ?? explicit.fullId);
-	}
-
-	if (baseModel.includes("/")) {
-		// Trust an explicit provider/model id even when the live catalog does not
-		// list it, mirroring the subagent resolver (resolveModelCandidate's
-		// `if (model.includes("/")) return model;`). The workflow catalog
-		// (ctx.modelRegistry.getAvailable()) can legitimately be a partial view
-		// (auth/provider gating, freshly added models), so treating an absent
-		// fully-qualified id as a hard failure made buildModelCandidates throw and
-		// collapse the whole ordered candidate list down to just the user's
-		// currentModel — discarding the workflow's defined primary and fallbacks.
-		// Pass it through with the reasoning suffix split off; the runtime fallback
-		// loop skips it only if the SDK genuinely cannot create a session for it.
-		return candidate(baseModel, baseModel);
-	}
-
-	const byBareId = models.filter((model) => model.id === baseModel);
-	if (byBareId.length === 0) {
-		return { input, reason: "not available" };
-	}
-	if (byBareId.length === 1) {
-		const only = byBareId[0]!;
-		return candidate(only.fullId, only.model ?? only.fullId);
-	}
-
-	const preferred =
-		preferredProvider === undefined ? undefined : byBareId.find((model) => model.provider === preferredProvider);
-	if (preferred !== undefined) {
-		return candidate(preferred.fullId, preferred.model ?? preferred.fullId);
-	}
-
-	return {
-		input,
-		reason: `ambiguous: ${byBareId.map((model) => model.fullId).join(", ")}; specify provider/model`,
-	};
-}
-
-function resolveModelValue(
-	value: WorkflowModelValue,
-	availableModels: readonly WorkflowModelInfo[] | undefined,
-	preferredProvider: string | undefined,
-): WorkflowResolvedModelCandidate | ModelResolutionFailure {
-	if (isModelObject(value)) {
-		return { id: workflowModelId(value)!, value };
-	}
-	return resolveStringModel(value, availableModels, preferredProvider);
-}
-
-function isFailure(value: WorkflowResolvedModelCandidate | ModelResolutionFailure): value is ModelResolutionFailure {
-	return "reason" in value;
-}
-
-export function buildModelCandidates(input: {
-	readonly primaryModel?: WorkflowModelValue;
-	readonly fallbackModels?: readonly string[];
-	readonly fallbackThinkingLevels?: readonly string[];
-	readonly currentModel?: WorkflowModelValue;
-	readonly availableModels?: readonly WorkflowModelInfo[];
-	readonly preferredProvider?: string;
-}): WorkflowResolvedModelCandidate[] {
-	const rawValues: WorkflowModelValue[] = [];
-	if (input.primaryModel !== undefined) rawValues.push(input.primaryModel);
-	for (const [index, fallback] of (input.fallbackModels ?? []).entries()) {
-		// Trim once up front so the suffix split, the validation error input, and the
-		// compat concatenation all operate on the same value. Concatenating the raw
-		// (untrimmed) fallback would push trailing whitespace into the interior of
-		// `id:level`, which `resolveStringModel` can no longer trim away.
-		const trimmedFallback = fallback.trim();
-		const split = splitReasoningSuffix(trimmedFallback);
-		const compatLevel = input.fallbackThinkingLevels?.[index];
-		if (split.level === undefined && compatLevel !== undefined) {
-			if (!WORKFLOW_THINKING_LEVEL_SET.has(compatLevel)) {
-				throw new WorkflowModelValidationError([
-					{
-						input: trimmedFallback,
-						reason: `invalid fallbackThinkingLevels[${index}] "${compatLevel}"; expected one of ${WORKFLOW_THINKING_LEVELS.join(", ")}`,
-					},
-				]);
-			}
-			rawValues.push(`${trimmedFallback}:${compatLevel}`);
-		} else {
-			rawValues.push(trimmedFallback);
-		}
-	}
-	if (input.currentModel !== undefined) rawValues.push(input.currentModel);
-
-	const failures: ModelResolutionFailure[] = [];
-	const seen = new Set<string>();
-	const candidates: WorkflowResolvedModelCandidate[] = [];
-	for (const value of rawValues) {
-		const resolved = resolveModelValue(value, input.availableModels, input.preferredProvider);
-		if (isFailure(resolved)) {
-			failures.push(resolved);
-			continue;
-		}
-		const key = candidateKey(resolved);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		candidates.push(resolved);
-	}
-
-	if (failures.length > 0) throw new WorkflowModelValidationError(failures);
-	return candidates;
-}
-
-export function buildModelCandidateIds(input: Parameters<typeof buildModelCandidates>[0]): string[] {
-	return buildModelCandidates(input).map((candidate) => candidate.id);
-}
-
-function catalogUnavailableWarning(): string {
-	return "workflows: model catalog unavailable; using the current selected model for fallback validation.";
-}
-
-export async function buildModelCandidatesFromCatalog(input: {
-	readonly primaryModel?: WorkflowModelValue;
-	readonly fallbackModels?: readonly string[];
-	readonly fallbackThinkingLevels?: readonly string[];
-	readonly catalog?: WorkflowModelCatalogPort;
-}): Promise<WorkflowResolvedModelCandidate[]> {
-	const hasExplicitModel = input.primaryModel !== undefined || (input.fallbackModels?.length ?? 0) > 0;
-	if (!hasExplicitModel) return [];
-
-	if (input.catalog === undefined) {
-		return buildModelCandidates({
-			primaryModel: input.primaryModel,
-			fallbackModels: input.fallbackModels,
-			fallbackThinkingLevels: input.fallbackThinkingLevels,
-		});
-	}
-
-	try {
-		const availableModels = await input.catalog.listModels();
-		return buildModelCandidates({
-			primaryModel: input.primaryModel,
-			fallbackModels: input.fallbackModels,
-			fallbackThinkingLevels: input.fallbackThinkingLevels,
-			currentModel: input.catalog.currentModel,
-			availableModels,
-			preferredProvider: input.catalog.preferredProvider,
-		});
-	} catch (err) {
-		if (input.catalog.currentModel === undefined) {
-			throw err;
-		}
-		input.catalog.recordWarning?.(catalogUnavailableWarning());
-		return buildModelCandidates({ currentModel: input.catalog.currentModel });
-	}
-}
-
-export async function validateWorkflowModels(input: {
-	readonly requests: readonly {
-		readonly model?: WorkflowModelValue;
-		readonly fallbackModels?: readonly string[];
-		readonly fallbackThinkingLevels?: readonly string[];
-	}[];
-	readonly catalog?: WorkflowModelCatalogPort;
-}): Promise<readonly string[]> {
-	const relevant = input.requests.filter(
-		(request) => request.model !== undefined || (request.fallbackModels?.length ?? 0) > 0,
-	);
-	if (relevant.length === 0) return [];
-
-	const warnings: string[] = [];
-	const recordWarning = (warning: string): void => {
-		warnings.push(warning);
-		input.catalog?.recordWarning?.(warning);
-	};
-
-	const failures: ModelResolutionFailure[] = [];
-	let availableModels: readonly WorkflowModelInfo[] | undefined;
-	if (input.catalog !== undefined) {
-		try {
-			availableModels = await input.catalog.listModels();
-		} catch (err) {
-			if (input.catalog.currentModel === undefined) throw err;
-			recordWarning(catalogUnavailableWarning());
-			return warnings;
-		}
-	}
-
-	for (const request of relevant) {
-		try {
-			buildModelCandidates({
-				primaryModel: request.model,
-				fallbackModels: request.fallbackModels,
-				fallbackThinkingLevels: request.fallbackThinkingLevels,
-				currentModel: input.catalog?.currentModel,
-				availableModels,
-				preferredProvider: input.catalog?.preferredProvider,
-			});
-		} catch (err) {
-			if (err instanceof WorkflowModelValidationError) failures.push(...err.failures);
-			else throw err;
-		}
-	}
-
-	if (failures.length > 0) throw new WorkflowModelValidationError(failures);
-	return warnings;
-}

package/dist/builtin/workflows/src/runs/shared/model-fallback-failures.ts

@@ -1,19 +0,0 @@
-/**
- * Compatibility exports for the shared Atomic model-failure classifier.
- *
- * The implementation lives in @bastani/atomic so the main chat, workflows,
- * and subagents cannot drift into separate fallback decisions.
- */
-
-export type {
-	ModelFallbackFailureKind,
-	ModelFallbackFailureSignal,
-	ModelFallbackFailureSource,
-} from "@bastani/atomic";
-export {
-	errorMessage,
-	isRetryableModelFailure,
-	isRetryableSameModelFailure,
-	modelFailureMessage,
-	normalizeModelFailureSignal,
-} from "@bastani/atomic";

package/dist/builtin/workflows/src/runs/shared/model-fallback.ts

@@ -1,2 +0,0 @@
-export * from "./model-fallback-candidates.js";
-export * from "./model-fallback-failures.js";

package/dist/builtin/workflows/src/runs/shared/prompt-callsite.ts

@@ -1,96 +0,0 @@
-/**
- * Prompt replay keys include a normalized workflow-author callsite so two
- * `ctx.ui.*` prompts with identical descriptors can still replay the matching
- * answer after continuation. Runtime/framework frames are filtered out; the
- * selected frame is hashed by the executor and never persisted in raw form.
- */
-
-import { fileURLToPath } from "node:url";
-
-export interface PromptCallsiteFrame {
-	readonly normalizedPath: string;
-	readonly lineNumber: string;
-	readonly columnNumber: string;
-}
-
-const PACKAGED_WORKFLOW_RUNTIME_ROOTS = [
-	"/dist/builtin/workflows/src/",
-	"/node_modules/@bastani/workflows/src/",
-] as const;
-
-function normalizeSlashes(path: string): string {
-	return path.replace(/\\/g, "/");
-}
-
-export function normalizeStackPath(framePath: string): string {
-	let normalized = framePath;
-	if (normalized.startsWith("file://")) {
-		try {
-			normalized = fileURLToPath(normalized);
-		} catch {
-			try {
-				normalized = decodeURIComponent(new URL(normalized).pathname);
-			} catch {
-				// Keep the original string; it will only be hashed, not persisted raw.
-			}
-		}
-	}
-
-	// Keep the normalized module/file identity absolute. Relativizing against
-	// mutable process.cwd() makes the same persisted workflow callsite hash
-	// differently when a later process starts from another directory.
-	normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
-
-	return normalized;
-}
-
-function currentModuleRuntimeRoot(): string | undefined {
-	const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
-	const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
-	for (const marker of markers) {
-		const index = modulePath.indexOf(marker);
-		if (index >= 0) return modulePath.slice(0, index + marker.length);
-	}
-	return undefined;
-}
-
-const CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
-
-export function isWorkflowRuntimeFrame(normalizedPath: string): boolean {
-	const path = normalizeSlashes(normalizedPath);
-	if (path.startsWith("packages/workflows/src/")) return true;
-	if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
-		return true;
-	}
-	const comparable = path.startsWith("/") ? path : `/${path}`;
-	return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
-}
-
-export function parsePromptStackFrame(stackLine: string): PromptCallsiteFrame | undefined {
-	const line = stackLine.trim();
-	if (line.length === 0) return undefined;
-	if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:")) return undefined;
-
-	const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
-	if (!match) return undefined;
-	const [, rawFramePath, lineNumber, columnNumber] = match;
-	if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined) return undefined;
-
-	const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
-	return { normalizedPath, lineNumber, columnNumber };
-}
-
-export function normalizedPromptCallsiteFrame(stackLine: string): string | undefined {
-	const frame = parsePromptStackFrame(stackLine);
-	if (frame === undefined) return undefined;
-	if (isWorkflowRuntimeFrame(frame.normalizedPath)) return undefined;
-	return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
-}
-
-export function selectPromptCallsiteFrame(stack: string): string | undefined {
-	return stack
-		.split("\n")
-		.slice(1)
-		.map(normalizedPromptCallsiteFrame)
-		.find((candidate): candidate is string => candidate !== undefined);
-}

package/dist/builtin/workflows/src/runs/shared/retry.ts

@@ -1,44 +0,0 @@
-/**
- * Compatibility exports for the shared Atomic retry policy, plus the workflow's
- * abort-aware sleep.
- *
- * The decision/backoff policy is implemented in @bastani/atomic so main chat and
- * workflow stages cannot drift into different budgets for the same
- * `settings.retry` values.
- */
-
-export type { RetryDecision, RetryPolicySettings } from "@bastani/atomic";
-export { nextRetryDecision } from "@bastani/atomic";
-
-type WorkflowAbortReason = Error | DOMException | string;
-
-function abortReason(signal: AbortSignal | undefined): WorkflowAbortReason {
-	const reason = signal?.reason;
-	if (reason instanceof Error || reason instanceof DOMException || typeof reason === "string") return reason;
-	return new Error("atomic-workflows: workflow cancelled");
-}
-
-/** Sleep for a bounded interval and reject promptly when the signal aborts. */
-export function sleepOrAbort(ms: number, signal?: AbortSignal): Promise<void> {
-	if (signal?.aborted) return Promise.reject(abortReason(signal));
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const cleanup = (): void => signal?.removeEventListener("abort", onAbort);
-		const finish = (): void => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve();
-		};
-		const fail = (error: WorkflowAbortReason): void => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			cleanup();
-			reject(error);
-		};
-		const timer = setTimeout(finish, Math.max(0, ms));
-		const onAbort = (): void => fail(abortReason(signal));
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}

package/dist/builtin/workflows/src/runs/shared/validate-inputs.ts

@@ -1,111 +0,0 @@
-/**
- * validateInputs — check a parsed input bag against a workflow's declared
- * TypeBox input schema. Used by slash-command and programmatic SDK dispatch
- * paths to reject malformed input payloads before dispatch.
- *
- * Reports:
- *   - unknown input keys (catches typos like "propmt")
- *   - wrong-typed values (number/boolean/string/select-union/integer)
- *   - select values not in the declared literal union
- *   - missing required inputs
- *   - non-JSON-serializable values
- *
- * Does NOT coerce: "true" is not a boolean, "3" is not a number. JSON parsing
- * upstream already preserves types — string-typed values reaching this point
- * are user mistakes worth surfacing.
- *
- * The legacy `{ type }` descriptor is gone; the field kind, choices, and
- * required-ness are derived from the TypeBox schema via schema-introspection,
- * keeping the historical error wording byte-for-byte stable.
- */
-
-import { Value } from "typebox/value";
-import { schemaChoices, schemaFieldKind, schemaIsRequired } from "../../shared/schema-introspection.js";
-import { workflowSerializableTypeName, workflowSerializableValidationError } from "../../shared/serializable.js";
-import type { TSchema, WorkflowInputValues } from "../../shared/types.js";
-
-export interface ValidationError {
-	key: string;
-	reason: string;
-}
-
-export function validateInputs(
-	schema: Readonly<Record<string, TSchema>>,
-	inputs: WorkflowInputValues,
-): ValidationError[] {
-	const errors: ValidationError[] = [];
-
-	for (const key of Object.keys(inputs)) {
-		if (!(key in schema)) {
-			errors.push({ key, reason: "unknown input key (not declared by this workflow)" });
-		}
-	}
-
-	for (const [key, def] of Object.entries(schema)) {
-		const value = inputs[key];
-		let hasTypeError = false;
-
-		if (value === undefined) {
-			if (schemaIsRequired(def)) {
-				errors.push({ key, reason: "required input is missing" });
-			}
-			continue;
-		}
-
-		const kind = schemaFieldKind(def);
-		switch (kind) {
-			case "text":
-				if (typeof value !== "string") {
-					errors.push({ key, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
-					hasTypeError = true;
-				}
-				break;
-			case "number":
-				if (typeof value !== "number" || !Number.isFinite(value)) {
-					errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
-					hasTypeError = true;
-				}
-				break;
-			case "integer":
-				if (typeof value !== "number" || !Number.isInteger(value)) {
-					errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
-					hasTypeError = true;
-				}
-				break;
-			case "boolean":
-				if (typeof value !== "boolean") {
-					errors.push({ key, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
-					hasTypeError = true;
-				}
-				break;
-			case "select": {
-				const choices = schemaChoices(def) ?? [];
-				const allowed = choices.join(", ");
-				if (typeof value !== "string") {
-					errors.push({ key, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
-					hasTypeError = true;
-				} else if (!choices.includes(value)) {
-					errors.push({ key, reason: `must be one of [${allowed}]` });
-				}
-				break;
-			}
-			default:
-				// object / array / unknown: defer to the schema's own checker so a
-				// precise declared shape (Type.Object({ ... }), Type.Array(...)) is
-				// still enforced, while loose schemas accept any serializable value.
-				if (!Value.Check(def, value)) {
-					const first = [...Value.Errors(def, value)][0];
-					errors.push({ key, reason: first === undefined ? `does not match ${kind} schema` : first.message });
-					hasTypeError = true;
-				}
-				break;
-		}
-
-		const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key}"`);
-		if (serializableError !== undefined) {
-			errors.push({ key, reason: serializableError.replace(/^input "[^"]+" /, "") });
-		}
-	}
-
-	return errors;
-}

package/dist/builtin/workflows/src/runs/shared/worktree-cache-lifecycle.ts

@@ -1,23 +0,0 @@
-import { createGitWorktreeSetupCache, type GitWorktreeSetupCache } from "./worktree-git.js";
-
-export interface GitWorktreeSetupCacheOwner {
-	readonly cache: GitWorktreeSetupCache;
-	release(finalizer: () => void): void;
-}
-
-export function createGitWorktreeSetupCacheOwner(suppliedCache?: GitWorktreeSetupCache): GitWorktreeSetupCacheOwner {
-	const cache = suppliedCache ?? createGitWorktreeSetupCache();
-	const ownsCache = suppliedCache === undefined;
-	let released = false;
-	return {
-		cache,
-		release(finalizer) {
-			try {
-				if (!released && ownsCache) cache.dispose();
-				released = true;
-			} finally {
-				finalizer();
-			}
-		},
-	};
-}