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

package/dist/builtin/workflows/src/runs/background/runner.ts

@@ -1,185 +0,0 @@
-/**
- * Detached runner — fires the sync executor in a background promise and
- * returns an immediate accepted result describing the dispatched run.
- *
- * Lifecycle:
- *   1. Preallocate runId (UUID).
- *   2. Create own AbortController.
- *   3. Register (runId, controller) in both CancellationRegistry and JobTracker.
- *   4. Start sync executor as background promise (no await).
- *   5. On settle: unregister from both registries, swallow any unhandled rejection.
- *   6. Return DetachedAccepted immediately.
- *
- * Does NOT wire slash/tool surfaces — callable API only.
- * cross-ref: spec detached-runner
- */
-
-import type { Store } from "../../shared/store.js";
-import { store as defaultStore } from "../../shared/store.js";
-import type {
-	WorkflowDefinition,
-	WorkflowExecutionMode,
-	WorkflowInputValues,
-	WorkflowOutputValues,
-} from "../../shared/types.js";
-import type { RunOpts, RunResult } from "../foreground/executor.js";
-import { run as syncRun } from "../foreground/executor.js";
-import type { CancellationRegistry } from "./cancellation-registry.js";
-import { cancellationRegistry as defaultCancellationRegistry } from "./cancellation-registry.js";
-import type { JobEntry, JobTracker } from "./job-tracker.js";
-import { jobTracker as defaultJobTracker } from "./job-tracker.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Immediate response returned by `runDetached()`. Background is the only
- * execution mode for workflow runs — this is the canonical "run accepted"
- * shape consumed by the dispatcher and rendered by `render-result`.
- */
-export interface DetachedAccepted {
-	readonly action: "run";
-	readonly name: string;
-	readonly runId: string;
-	readonly status: "running";
-	readonly message: string;
-	readonly stages: [];
-}
-
-export interface DetachedRunOpts extends Omit<RunOpts, "signal" | "cancellation" | "deferWorkflowStart"> {
-	/**
-	 * Override CancellationRegistry (default: singleton cancellationRegistry).
-	 */
-	cancellation?: CancellationRegistry;
-	/**
-	 * Override JobTracker (default: singleton jobTracker).
-	 */
-	jobs?: JobTracker;
-	/** Runtime execution mode for UI/prompt policy. Defaults to interactive. */
-	executionMode?: WorkflowExecutionMode;
-	/**
-	 * Observes the raw executor outcome. Fulfillment includes the executor's
-	 * RunResult; rejection includes the thrown setup/final-flush error. The job
-	 * promise still resolves either way.
-	 */
-	onRawSettled?: (ok: boolean, result: RunResult | undefined, error: unknown | undefined) => void;
-}
-
-// ---------------------------------------------------------------------------
-// Helper — build accepted result object
-// ---------------------------------------------------------------------------
-
-export function workflowConnectGuidance(runId: string): string {
-	return `Run /workflow connect ${runId} to see agents working and chat with and steer each stage.`;
-}
-
-export function buildDetachedAccepted(name: string, runId: string): DetachedAccepted {
-	return {
-		action: "run",
-		name,
-		runId,
-		status: "running",
-		message: `Workflow "${name}" started in background (runId: ${runId}). ${workflowConnectGuidance(runId)}`,
-		stages: [],
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-
-/**
- * Start a workflow run in the background and return immediately.
- *
- * The background promise is fire-and-forget from the caller's perspective;
- * the store remains source of truth for run status. Cancellation is wired
- * through the provided (or default) CancellationRegistry.
- */
-export function runDetached<TInputs extends WorkflowInputValues, TRunInputs extends WorkflowInputValues = TInputs>(
-	def: WorkflowDefinition<TInputs, WorkflowOutputValues, TRunInputs>,
-	inputs: Readonly<Record<string, unknown>>,
-	opts: DetachedRunOpts = {},
-): DetachedAccepted {
-	const registry = opts.cancellation ?? defaultCancellationRegistry;
-	const tracker = opts.jobs ?? defaultJobTracker;
-
-	// 1. Pre-allocate runId unless the caller supplied one for continuation/tests.
-	const runId = opts.runId ?? crypto.randomUUID();
-
-	// 2. Create AbortController for this run
-	const controller = new AbortController();
-
-	// 3. Register in cancellation registry BEFORE starting background promise
-	//    so any concurrent abort() calls issued immediately after runDetached()
-	//    are not lost.
-	registry.register(runId, controller);
-
-	// 4. Build executor opts — inject runId seam, signal, and node-local
-	//    store-backed HIL. Background runs must NOT route ctx.ui.* through pi.ui
-	//    dialogs (those steal focus from the main chat editor); the executor
-	//    records prompts on synthetic workflow nodes and the attached stage chat
-	//    drives the response. Destructure `jobs`/`cancellation`/`ui` out so
-	//    they're not forwarded to RunOpts twice.
-	const { jobs: _jobs, cancellation: _cancellation, ui: _ui, store: storeOverride, onRawSettled, ...restOpts } = opts;
-	const store: Store = storeOverride ?? defaultStore;
-	const execOpts: RunOpts = {
-		...restOpts,
-		runId,
-		signal: controller.signal,
-		cancellation: registry,
-		store,
-		usePromptNodesForUi: opts.executionMode !== "non_interactive",
-		deferWorkflowStart: true,
-	};
-
-	// 5-7. Register the job BEFORE starting the executor, so a registration
-	//   failure can never leave a started (and now-orphaned) executor running.
-	//   The job promise settles when the executor settles; it is wired below.
-	//   Cleanup is identity-conditional throughout: an abandoned executor may
-	//   settle long after a resume registered its replacement under the same run
-	//   id, and it must never evict that replacement.
-	let settleJob: () => void = () => {};
-	const voidPromise: Promise<void> = new Promise<void>((resolve) => {
-		settleJob = resolve;
-	});
-	const jobEntry: JobEntry = { runId, controller, promise: voidPromise };
-	try {
-		tracker.register(jobEntry);
-	} catch (error) {
-		controller.abort(error);
-		registry.unregister(runId, controller);
-		settleJob();
-		throw error;
-	}
-	let backgroundPromise: Promise<RunResult>;
-	try {
-		backgroundPromise = syncRun(def, inputs, execOpts);
-	} catch (error) {
-		controller.abort(error);
-		registry.unregister(runId, controller);
-		tracker.unregister(runId, jobEntry);
-		settleJob();
-		throw error;
-	}
-	const settle = (ok: boolean, result: RunResult | undefined, error: unknown | undefined): void => {
-		try {
-			onRawSettled?.(ok, result, error);
-		} finally {
-			registry.unregister(runId, controller);
-			tracker.unregister(runId, jobEntry);
-			settleJob();
-		}
-	};
-	void backgroundPromise.then(
-		(result) => {
-			settle(true, result, undefined);
-		},
-		(error: unknown) => {
-			settle(false, undefined, error);
-		},
-	);
-
-	// 8. Return immediate accepted result
-	return buildDetachedAccepted(def.name, runId);
-}

package/dist/builtin/workflows/src/runs/background/startup-admission.ts

@@ -1,73 +0,0 @@
-import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../../shared/types.js";
-import type { RunResult } from "../foreground/executor-types.js";
-import { type DetachedAccepted, type DetachedRunOpts, runDetached } from "./runner.js";
-
-export type WorkflowStartupAdmission =
-	| { readonly started: true }
-	| {
-			readonly started: false;
-			readonly resultError: string | undefined;
-			readonly error: unknown | undefined;
-	  };
-
-export interface WorkflowStartupObserver {
-	readonly wait: Promise<WorkflowStartupAdmission>;
-	readonly onWorkflowStartReady: () => void;
-	readonly onRawSettled: (ok: boolean, result: RunResult | undefined, error: unknown | undefined) => void;
-}
-
-/** Resolve startup readiness separately from later workflow-body settlement. */
-export function createWorkflowStartupObserver(beforeReady?: () => void): WorkflowStartupObserver {
-	const startup = Promise.withResolvers<WorkflowStartupAdmission>();
-	return {
-		wait: startup.promise,
-		onWorkflowStartReady: () => {
-			beforeReady?.();
-			startup.resolve({ started: true });
-		},
-		onRawSettled: (_ok, result, error) => {
-			startup.resolve({ started: false, resultError: result?.error, error });
-		},
-	};
-}
-export function launchDetachedUntilStartup<
-	TInputs extends WorkflowInputValues,
-	TRunInputs extends WorkflowInputValues = TInputs,
->(
-	def: WorkflowDefinition<TInputs, WorkflowOutputValues, TRunInputs>,
-	inputs: Readonly<Record<string, unknown>>,
-	opts: DetachedRunOpts = {},
-): { readonly accepted: DetachedAccepted; readonly wait: Promise<WorkflowStartupAdmission> } {
-	const priorReady = opts.onWorkflowStartReady;
-	const priorSettled = opts.onRawSettled;
-	const startup = createWorkflowStartupObserver(priorReady);
-	const accepted = runDetached(def, inputs, {
-		...opts,
-		onWorkflowStartReady: startup.onWorkflowStartReady,
-		onRawSettled: (ok, result, error) => {
-			try {
-				priorSettled?.(ok, result, error);
-			} finally {
-				startup.onRawSettled(ok, result, error);
-			}
-		},
-	});
-	return { accepted, wait: startup.wait };
-}
-
-export function workflowStartupFailureMessage(
-	admission: Extract<WorkflowStartupAdmission, { started: false }>,
-	snapshotError: string | undefined,
-	fallback: string,
-): string {
-	return (
-		admission.resultError ??
-		snapshotError ??
-		(admission.error instanceof Error
-			? admission.error.message
-			: admission.error === undefined
-				? undefined
-				: String(admission.error)) ??
-		fallback
-	);
-}