@warlock.js/ai 4.1.1

package/esm/workflow/as-tool.mjs

@@ -0,0 +1,55 @@
+import { WorkflowError } from "../errors/workflow-error.mjs";
+import "../errors/index.mjs";
+import { compositeAsTool } from "../tool/tool.mjs";
+
+//#region ../../@warlock.js/ai/src/workflow/as-tool.ts
+/**
+* Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke
+* it inside its tool-call loop. Closes the agent-calls-workflow
+* composition gap.
+*
+* Behavior:
+* - Tool `name` mirrors `workflow.name` — workflows without a name throw
+*   `WorkflowError` at wrap time (the agent surface needs a stable id).
+* - Tool `input` is the supplied `inputSchema`; the validated value is
+*   forwarded straight to `workflow.execute(input)`.
+* - On `result.error`, the workflow error is wrapped in
+*   `ToolExecutionError` with `cause` set to the original
+*   `WorkflowError` subclass — the agent's tool-call loop sees a
+*   uniform error class regardless of which primitive failed.
+*
+* **Usage caveat (deferred to Phase 2):** the parent agent's
+* `result.usage` does NOT roll up tokens consumed inside the wrapped
+* workflow today. Nested-usage standardization lands with the
+* supervisor work; until then, sum workflow + agent usage manually if
+* you need a combined cost figure.
+*
+* @example
+* const wf = workflow({ name: "triage", steps: [...] });
+* const triageTool = asTool(wf, {
+*   description: "Run the support-ticket triage flow",
+*   inputSchema: ticketSchema,
+* });
+* const a = ai.agent({ model, tools: [triageTool] });
+*/
+function asTool(workflowInstance, options) {
+	if (!workflowInstance.name || typeof workflowInstance.name !== "string") throw new WorkflowError("workflow.asTool(): workflow must have a `name` to be wrapped as a tool");
+	return compositeAsTool({
+		name: workflowInstance.name,
+		description: options.description ?? `Invoke workflow "${workflowInstance.name}" as a tool.`,
+		input: options.inputSchema,
+		execute: async (input) => {
+			const result = await workflowInstance.execute(input);
+			if (result.error) throw result.error;
+			return {
+				data: result.data,
+				usage: result.usage,
+				report: result.report
+			};
+		}
+	});
+}
+
+//#endregion
+export { asTool };
+//# sourceMappingURL=as-tool.mjs.map

package/esm/workflow/as-tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-tool.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/workflow/as-tool.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowInstance } from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"../tool/tool\";\n\n/**\n * Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke\n * it inside its tool-call loop. Closes the agent-calls-workflow\n * composition gap.\n *\n * Behavior:\n * - Tool `name` mirrors `workflow.name` — workflows without a name throw\n *   `WorkflowError` at wrap time (the agent surface needs a stable id).\n * - Tool `input` is the supplied `inputSchema`; the validated value is\n *   forwarded straight to `workflow.execute(input)`.\n * - On `result.error`, the workflow error is wrapped in\n *   `ToolExecutionError` with `cause` set to the original\n *   `WorkflowError` subclass — the agent's tool-call loop sees a\n *   uniform error class regardless of which primitive failed.\n *\n * **Usage caveat (deferred to Phase 2):** the parent agent's\n * `result.usage` does NOT roll up tokens consumed inside the wrapped\n * workflow today. Nested-usage standardization lands with the\n * supervisor work; until then, sum workflow + agent usage manually if\n * you need a combined cost figure.\n *\n * @example\n * const wf = workflow({ name: \"triage\", steps: [...] });\n * const triageTool = asTool(wf, {\n *   description: \"Run the support-ticket triage flow\",\n *   inputSchema: ticketSchema,\n * });\n * const a = ai.agent({ model, tools: [triageTool] });\n */\nexport function asTool<TInput, TOutput, TToolInput = TInput>(\n  workflowInstance: WorkflowInstance<TInput, TOutput>,\n  options: {\n    description?: string;\n    inputSchema: StandardSchemaV1<TToolInput>;\n  },\n): ToolContract<TToolInput, TOutput> {\n  if (!workflowInstance.name || typeof workflowInstance.name !== \"string\") {\n    throw new WorkflowError(\n      \"workflow.asTool(): workflow must have a `name` to be wrapped as a tool\",\n    );\n  }\n\n  return compositeAsTool<TToolInput, TOutput>({\n    name: workflowInstance.name,\n    description: options.description ?? `Invoke workflow \"${workflowInstance.name}\" as a tool.`,\n    input: options.inputSchema,\n    execute: async (input) => {\n      const result = await workflowInstance.execute(input as unknown as TInput);\n\n      if (result.error) {\n        // Throw the workflow error so the surrounding wrapper catches\n        // it and produces a `ToolExecutionError` with `cause` pointing\n        // back at the original `WorkflowError` subclass — keeps the\n        // agent's tool-call loop seeing one uniform error class\n        // regardless of which primitive failed.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage,\n        report: result.report,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,OACd,kBACA,SAImC;CACnC,IAAI,CAAC,iBAAiB,QAAQ,OAAO,iBAAiB,SAAS,UAC7D,MAAM,IAAI,cACR,wEACF;CAGF,OAAO,gBAAqC;EAC1C,MAAM,iBAAiB;EACvB,aAAa,QAAQ,eAAe,oBAAoB,iBAAiB,KAAK;EAC9E,OAAO,QAAQ;EACf,SAAS,OAAO,UAAU;GACxB,MAAM,SAAS,MAAM,iBAAiB,QAAQ,KAA0B;GAExE,IAAI,OAAO,OAMT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH"}

package/esm/workflow/cancellation.mjs

@@ -0,0 +1,44 @@
+import { WorkflowCancelledError } from "../errors/workflow-cancelled-error.mjs";
+import "../errors/index.mjs";
+
+//#region ../../@warlock.js/ai/src/workflow/cancellation.ts
+/**
+* Build a `WorkflowCancelledError` from an `AbortSignal`, extracting
+* a human-readable reason from `signal.reason` (string | Error | any).
+* Used both at between-step boundaries and inside the retry backoff
+* sleep.
+*/
+function createCancelledError(signal) {
+	const reason = signal?.reason;
+	const reasonText = typeof reason === "string" ? reason : reason instanceof Error ? reason.message : reason === void 0 ? "" : String(reason);
+	return new WorkflowCancelledError(`workflow cancelled${reasonText ? `: ${reasonText}` : ""}`, {
+		cancelledAt: (/* @__PURE__ */ new Date()).toISOString(),
+		reason: reasonText
+	});
+}
+/**
+* Promise-based sleep that resolves after `ms` milliseconds, or
+* rejects with `WorkflowCancelledError` if the signal fires. The
+* timer is cleared on abort so we never leak a pending setTimeout.
+*/
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(createCancelledError(signal));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(createCancelledError(signal));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+//#endregion
+export { createCancelledError, sleep };
+//# sourceMappingURL=cancellation.mjs.map

package/esm/workflow/cancellation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancellation.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/workflow/cancellation.ts"],"sourcesContent":["import { WorkflowCancelledError } from \"../errors\";\n\n/**\n * Build a `WorkflowCancelledError` from an `AbortSignal`, extracting\n * a human-readable reason from `signal.reason` (string | Error | any).\n * Used both at between-step boundaries and inside the retry backoff\n * sleep.\n */\nexport function createCancelledError(\n  signal: AbortSignal | undefined,\n): WorkflowCancelledError {\n  const reason = signal?.reason;\n  const reasonText =\n    typeof reason === \"string\"\n      ? reason\n      : reason instanceof Error\n        ? reason.message\n        : reason === undefined\n          ? \"\"\n          : String(reason);\n\n  return new WorkflowCancelledError(\n    `workflow cancelled${reasonText ? `: ${reasonText}` : \"\"}`,\n    { cancelledAt: new Date().toISOString(), reason: reasonText },\n  );\n}\n\n/**\n * Promise-based sleep that resolves after `ms` milliseconds, or\n * rejects with `WorkflowCancelledError` if the signal fires. The\n * timer is cleared on abort so we never leak a pending setTimeout.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(createCancelledError(signal));\n      return;\n    }\n\n    const timer = setTimeout(() => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(createCancelledError(signal));\n    };\n\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,qBACd,QACwB;CACxB,MAAM,SAAS,QAAQ;CACvB,MAAM,aACJ,OAAO,WAAW,WACd,SACA,kBAAkB,QAChB,OAAO,UACP,WAAW,SACT,KACA,OAAO,MAAM;CAEvB,OAAO,IAAI,uBACT,qBAAqB,aAAa,KAAK,eAAe,MACtD;EAAE,8BAAa,IAAI,KAAK,GAAE,YAAY;EAAG,QAAQ;CAAW,CAC9D;AACF;;;;;;AAOA,SAAgB,MAAM,IAAY,QAAqC;CACrE,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI,QAAQ,SAAS;GACnB,OAAO,qBAAqB,MAAM,CAAC;GACnC;EACF;EAEA,MAAM,QAAQ,iBAAiB;GAC7B,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACV,GAAG,EAAE;EAEL,MAAM,gBAAgB;GACpB,aAAa,KAAK;GAClB,OAAO,qBAAqB,MAAM,CAAC;EACrC;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC3D,CAAC;AACH"}

package/esm/workflow/emitter.mjs

@@ -0,0 +1,40 @@
+//#region ../../@warlock.js/ai/src/workflow/emitter.ts
+/**
+* Three-tier workflow event emitter — factory (definition) → instance →
+* per-execution. All matching handlers fire, in layer order. Handler
+* errors are swallowed so listener bugs can never derail the workflow.
+*/
+var WorkflowEmitter = class {
+	constructor(factoryHandlers) {
+		this.instanceHandlers = /* @__PURE__ */ new Map();
+		this.factoryHandlers = factoryHandlers;
+	}
+	on(event, handler) {
+		let bucket = this.instanceHandlers.get(event);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Set();
+			this.instanceHandlers.set(event, bucket);
+		}
+		bucket.add(handler);
+		return () => this.off(event, handler);
+	}
+	off(event, handler) {
+		this.instanceHandlers.get(event)?.delete(handler);
+	}
+	emit(event, payload, executionHandlers) {
+		invoke(this.factoryHandlers?.[event], payload);
+		const bucket = this.instanceHandlers.get(event);
+		if (bucket) for (const handler of bucket) invoke(handler, payload);
+		invoke(executionHandlers?.[event], payload);
+	}
+};
+function invoke(handler, payload) {
+	if (typeof handler !== "function") return;
+	try {
+		handler(payload);
+	} catch {}
+}
+
+//#endregion
+export { WorkflowEmitter };
+//# sourceMappingURL=emitter.mjs.map

package/esm/workflow/emitter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/workflow/emitter.ts"],"sourcesContent":["import type { WithoutIdentity } from \"../contracts/events/event-identity.type\";\nimport type { WorkflowEventMap } from \"../contracts/events/event-map.type\";\nimport type {\n  WorkflowEventHandler,\n  WorkflowEventHandlers,\n} from \"../contracts/workflow/workflow.contract\";\n\ntype AnyHandler = WorkflowEventHandler<keyof WorkflowEventMap>;\n\n/**\n * The emit surface the workflow engine and step-runner depend on.\n * They never construct run identity themselves — they hand a bare\n * payload to a sink that injects `runId` / `rootRunId` before\n * delegating to the real three-tier `WorkflowEmitter`.\n *\n * `WorkflowEmitter` is factory-scoped (shared across every\n * `execute()`), so it cannot own per-run identity. A per-run sink\n * (see `runScopedEmitter`) closes that gap without touching the ~15\n * `emit` call sites in `engine.ts` / `step-runner.ts`.\n */\nexport interface WorkflowEventSink {\n  emit<K extends keyof WorkflowEventMap>(\n    event: K,\n    payload: WithoutIdentity<WorkflowEventMap[K]>,\n    executionHandlers?: WorkflowEventHandlers,\n  ): void;\n}\n\n/**\n * Three-tier workflow event emitter — factory (definition) → instance →\n * per-execution. All matching handlers fire, in layer order. Handler\n * errors are swallowed so listener bugs can never derail the workflow.\n */\nexport class WorkflowEmitter {\n  private readonly factoryHandlers?: WorkflowEventHandlers;\n  private readonly instanceHandlers = new Map<\n    keyof WorkflowEventMap,\n    Set<AnyHandler>\n  >();\n\n  public constructor(factoryHandlers?: WorkflowEventHandlers) {\n    this.factoryHandlers = factoryHandlers;\n  }\n\n  public on<K extends keyof WorkflowEventMap>(\n    event: K,\n    handler: WorkflowEventHandler<K>,\n  ): () => void {\n    let bucket = this.instanceHandlers.get(event);\n    if (!bucket) {\n      bucket = new Set();\n      this.instanceHandlers.set(event, bucket);\n    }\n    bucket.add(handler as AnyHandler);\n    return () => this.off(event, handler);\n  }\n\n  public off<K extends keyof WorkflowEventMap>(\n    event: K,\n    handler: WorkflowEventHandler<K>,\n  ): void {\n    this.instanceHandlers.get(event)?.delete(handler as AnyHandler);\n  }\n\n  public emit<K extends keyof WorkflowEventMap>(\n    event: K,\n    payload: WorkflowEventMap[K],\n    executionHandlers?: WorkflowEventHandlers,\n  ): void {\n    // Layer 1 — factory\n    invoke(this.factoryHandlers?.[event], payload);\n\n    // Layer 2 — instance (set-based, possibly many handlers)\n    const bucket = this.instanceHandlers.get(event);\n    if (bucket) {\n      for (const handler of bucket) invoke(handler, payload);\n    }\n\n    // Layer 3 — per-execution\n    invoke(executionHandlers?.[event], payload);\n  }\n}\n\nfunction invoke<K extends keyof WorkflowEventMap>(\n  handler: ((payload: WorkflowEventMap[K]) => void) | undefined,\n  payload: WorkflowEventMap[K],\n): void {\n  if (typeof handler !== \"function\") return;\n  try {\n    handler(payload);\n  } catch {\n    // Swallow — listener bugs must not derail workflow execution.\n  }\n}\n"],"mappings":";;;;;;AAiCA,IAAa,kBAAb,MAA6B;CAO3B,AAAO,YAAY,iBAAyC;0CALxB,IAAI,IAGtC;EAGA,KAAK,kBAAkB;CACzB;CAEA,AAAO,GACL,OACA,SACY;EACZ,IAAI,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAC5C,IAAI,CAAC,QAAQ;GACX,yBAAS,IAAI,IAAI;GACjB,KAAK,iBAAiB,IAAI,OAAO,MAAM;EACzC;EACA,OAAO,IAAI,OAAqB;EAChC,aAAa,KAAK,IAAI,OAAO,OAAO;CACtC;CAEA,AAAO,IACL,OACA,SACM;EACN,KAAK,iBAAiB,IAAI,KAAK,GAAG,OAAO,OAAqB;CAChE;CAEA,AAAO,KACL,OACA,SACA,mBACM;EAEN,OAAO,KAAK,kBAAkB,QAAQ,OAAO;EAG7C,MAAM,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAC9C,IAAI,QACF,KAAK,MAAM,WAAW,QAAQ,OAAO,SAAS,OAAO;EAIvD,OAAO,oBAAoB,QAAQ,OAAO;CAC5C;AACF;AAEA,SAAS,OACP,SACA,SACM;CACN,IAAI,OAAO,YAAY,YAAY;CACnC,IAAI;EACF,QAAQ,OAAO;CACjB,QAAQ,CAER;AACF"}

package/esm/workflow/engine.mjs

@@ -0,0 +1,362 @@
+import { AIError } from "../errors/ai-error.mjs";
+import { WorkflowError } from "../errors/workflow-error.mjs";
+import { MaxStepsExceededError } from "../errors/max-steps-exceeded-error.mjs";
+import { RoutingError } from "../errors/routing-error.mjs";
+import { SchemaValidationError } from "../errors/schema-validation-error.mjs";
+import { WorkflowCancelledError } from "../errors/workflow-cancelled-error.mjs";
+import "../errors/index.mjs";
+import { stampReportLineage } from "../utils/stamp-report-lineage.mjs";
+import "../utils/index.mjs";
+import { createCancelledError } from "./cancellation.mjs";
+import { mapNextStep, nextDeclaredStep, resolveNextStep } from "./router.mjs";
+import { runScopedEmitter } from "./run-scoped-emitter.mjs";
+import { loadSnapshotForResume, persistSnapshot } from "./snapshot.mjs";
+import { cloneState, deepFreeze } from "./state.mjs";
+import { executeStep, finalizeSnapshot, toAIError } from "./step-runner.mjs";
+import { log } from "@warlock.js/logger";
+
+//#region ../../@warlock.js/ai/src/workflow/engine.ts
+const DEFAULT_MAX_STEPS = 100;
+const DEFAULT_LOOP_WARN = 5;
+const LOG_MODULE_BASE = "ai.workflow";
+/**
+* Main workflow driver. Walks the declared steps, handling routing,
+* cancellation, retries, parallel execution, and snapshot
+* persistence. Delegates the step lifecycle to `step-runner.ts`,
+* routing to `router.ts`, persistence to `snapshot.ts`. Never throws
+* — every failure funnels into `result.error`.
+*/
+async function runWorkflow(params) {
+	const { definition, signature, input, runId, signal } = params;
+	const emitter = runScopedEmitter(params.emitter, {
+		runId,
+		rootRunId: runId
+	});
+	const context = Object.freeze(params.context ?? {});
+	const maxSteps = definition.maxSteps ?? DEFAULT_MAX_STEPS;
+	const loopWarnAfter = definition.loopWarnAfter ?? DEFAULT_LOOP_WARN;
+	const logger = log;
+	const logModule = `${LOG_MODULE_BASE}.${definition.name}`;
+	const stepByName = /* @__PURE__ */ new Map();
+	for (const s of definition.steps) stepByName.set(s.name, s);
+	const state = params.resumeFrom ? { ...params.resumeFrom.state } : {};
+	const steps = params.resumeFrom ? { ...params.resumeFrom.steps } : {};
+	const enteredCount = /* @__PURE__ */ new Map();
+	const usage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	const startedAt = params.resumeFrom?.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const startedAtDate = new Date(startedAt);
+	const runStartPerf = performance.now();
+	let error;
+	let status = "completed";
+	let cancelledAt;
+	let lastGoto = null;
+	let failedStepName;
+	const buildContext = (current) => ({
+		input,
+		context,
+		steps,
+		state: current?.state ?? state,
+		agentResult: current?.agentResult,
+		runId,
+		signal,
+		startedAt: startedAtDate
+	});
+	emitter.emit("workflow.starting", {
+		workflowName: definition.name,
+		input
+	}, params.executionHandlers);
+	logger.info(logModule, "starting", "workflow starting", { runId });
+	let currentName = resolveInitialStep(definition, params.resumeFrom);
+	let stepCount = 0;
+	try {
+		while (currentName !== null) {
+			if (signal?.aborted) throw createCancelledError(signal);
+			stepCount += 1;
+			if (stepCount > maxSteps) throw new MaxStepsExceededError(`workflow "${definition.name}" exceeded maxSteps=${maxSteps}`, { maxSteps });
+			const entered = (enteredCount.get(currentName) ?? 0) + 1;
+			enteredCount.set(currentName, entered);
+			if (entered === loopWarnAfter) {
+				emitter.emit("workflow.loop.warning", {
+					step: currentName,
+					enteredCount: entered,
+					lastGoto
+				}, params.executionHandlers);
+				logger.warn(logModule, "loop.warning", "loop warning", {
+					step: currentName,
+					enteredCount: entered
+				});
+			}
+			const step = stepByName.get(currentName);
+			if (!step) throw new RoutingError(`workflow "${definition.name}": unknown step "${currentName}"`, { stepName: currentName });
+			const snapshot = await executeStep({
+				step,
+				state,
+				emitter,
+				executionHandlers: params.executionHandlers,
+				logger,
+				logModule,
+				signal,
+				buildContext,
+				usage,
+				workflowDefaultRetry: definition.defaultRetry
+			});
+			Object.assign(state, snapshot.state);
+			steps[step.name] = finalizeSnapshot(snapshot);
+			if (snapshot.steps) for (const [childName, childSnap] of Object.entries(snapshot.steps)) steps[childName] = childSnap;
+			if (snapshot.status === "failed" && snapshot.error) {
+				const failureRoute = await resolveFailureRoute({
+					step,
+					definition,
+					error: snapshot.error,
+					ctx: buildContext({
+						state,
+						agentResult: snapshot.executionResult
+					})
+				});
+				if (failureRoute === void 0) {
+					const persistOutcome = await persistSnapshot({
+						definition,
+						signature,
+						runId,
+						startedAt,
+						input,
+						state,
+						steps,
+						next: step.name,
+						status: "running"
+					});
+					if (!persistOutcome.ok) {
+						const persistErr = toAIError(persistOutcome.error);
+						emitter.emit("workflow.error", { error: persistErr }, params.executionHandlers);
+						logger.error(logModule, "persist.failed", "snapshot persist failed", {
+							step: step.name,
+							code: persistErr.code,
+							message: persistErr.message
+						});
+					}
+					failedStepName = step.name;
+					throw snapshot.error;
+				}
+				const failureNext = failureRoute === "end" ? null : failureRoute;
+				if (failureNext !== null && !stepByName.has(failureNext)) throw new RoutingError(`workflow "${definition.name}": step "${step.name}" onFailure routed to unknown target "${failureNext}"`, {
+					stepName: step.name,
+					targetName: failureNext
+				});
+				const failurePersist = await persistSnapshot({
+					definition,
+					signature,
+					runId,
+					startedAt,
+					input,
+					state,
+					steps,
+					next: failureNext,
+					status: "running"
+				});
+				if (!failurePersist.ok) {
+					const persistErr = toAIError(failurePersist.error);
+					emitter.emit("workflow.error", { error: persistErr }, params.executionHandlers);
+					logger.error(logModule, "persist.failed", "snapshot persist failed", {
+						step: step.name,
+						code: persistErr.code,
+						message: persistErr.message
+					});
+				}
+				if (signal?.aborted) throw createCancelledError(signal);
+				if (failureRoute === "end") {
+					currentName = null;
+					break;
+				}
+				lastGoto = failureRoute;
+				currentName = failureRoute;
+				continue;
+			}
+			const resolved = await resolveNextStep({
+				step,
+				definition,
+				ctx: buildContext({
+					state,
+					agentResult: snapshot.executionResult
+				})
+			});
+			const nextName = resolved === "end" ? null : typeof resolved === "string" ? resolved : nextDeclaredStep(definition, step.name);
+			const outcome = await persistSnapshot({
+				definition,
+				signature,
+				runId,
+				startedAt,
+				input,
+				state,
+				steps,
+				next: nextName,
+				status: "running"
+			});
+			if (!outcome.ok) {
+				const persistErr = toAIError(outcome.error);
+				emitter.emit("workflow.error", { error: persistErr }, params.executionHandlers);
+				logger.error(logModule, "persist.failed", "snapshot persist failed", {
+					step: step.name,
+					code: persistErr.code,
+					message: persistErr.message
+				});
+			}
+			if (signal?.aborted) throw createCancelledError(signal);
+			if (resolved === "end") {
+				currentName = null;
+				break;
+			}
+			if (typeof resolved === "string") {
+				if (!stepByName.has(resolved)) throw new RoutingError(`workflow "${definition.name}": step "${step.name}" goto unknown target "${resolved}"`, {
+					stepName: step.name,
+					targetName: resolved
+				});
+				lastGoto = resolved;
+				currentName = resolved;
+				continue;
+			}
+			currentName = nextName;
+			lastGoto = currentName;
+		}
+	} catch (err) {
+		if (err instanceof WorkflowCancelledError) {
+			status = "cancelled";
+			cancelledAt = err.cancelledAt;
+			error = err;
+		} else if (err instanceof AIError) {
+			status = "failed";
+			error = err;
+		} else {
+			status = "failed";
+			error = new WorkflowError(err instanceof Error ? err.message : String(err), { cause: err });
+		}
+	}
+	const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const duration = performance.now() - runStartPerf;
+	let data;
+	if (status === "completed" && definition.output) try {
+		const extracted = await definition.output.extract(buildContext({ state }));
+		data = await validateWorkflowOutput(definition.output.schema, extracted);
+	} catch (err) {
+		status = "failed";
+		error = err instanceof AIError ? err : new WorkflowError(err instanceof Error ? err.message : String(err), { cause: err });
+	}
+	const children = [];
+	for (const stepName in steps) {
+		const snap = steps[stepName];
+		if (snap.agentReport) children.push(snap.agentReport);
+	}
+	const report = {
+		runId,
+		rootRunId: runId,
+		name: definition.name,
+		version: definition.version,
+		type: "workflow",
+		workflowName: definition.name,
+		signature,
+		status,
+		startedAt,
+		endedAt,
+		duration,
+		cancelledAt,
+		usage,
+		children,
+		steps,
+		state: deepFreeze(cloneState(state))
+	};
+	stampReportLineage(report, {
+		rootRunId: runId,
+		sessionId: params.sessionId
+	});
+	const finalOutcome = await persistSnapshot({
+		definition,
+		signature,
+		runId,
+		startedAt,
+		input,
+		state,
+		steps,
+		next: status === "failed" ? failedStepName ?? null : null,
+		status
+	});
+	if (!finalOutcome.ok) {
+		const persistErr = toAIError(finalOutcome.error);
+		emitter.emit("workflow.error", { error: persistErr }, params.executionHandlers);
+		logger.error(logModule, "persist.failed", "final snapshot persist failed", {
+			code: persistErr.code,
+			message: persistErr.message
+		});
+	}
+	const result = {
+		type: "workflow",
+		data,
+		report,
+		usage,
+		error
+	};
+	if (status === "cancelled") {
+		emitter.emit("workflow.cancelled", {
+			cancelledAt: cancelledAt ?? endedAt,
+			reason: error?.reason ?? ""
+		}, params.executionHandlers);
+		logger.warn(logModule, "cancelled", "workflow cancelled", { runId });
+	}
+	if (status === "failed" && error) {
+		emitter.emit("workflow.error", { error }, params.executionHandlers);
+		logger.error(logModule, "error", "workflow failed", {
+			runId,
+			code: error.code,
+			message: error.message
+		});
+	}
+	emitter.emit("workflow.completed", { result }, params.executionHandlers);
+	logger.info(logModule, "completed", "workflow completed", {
+		runId,
+		status,
+		duration
+	});
+	return result;
+}
+/**
+* Run a failed step's `onFailure` hook (if present) and translate its
+* result into a route. Returns `undefined` when the workflow should
+* halt with the original error; `"end"` for clean termination; or a
+* step name to redirect to. A throw inside `onFailure` is wrapped in
+* `RoutingError` — routing is authoritative, never retried.
+*/
+async function resolveFailureRoute(params) {
+	const { step, definition, error, ctx } = params;
+	if (!step.onFailure) return void 0;
+	let outcome;
+	try {
+		outcome = await step.onFailure(ctx, error);
+	} catch (err) {
+		throw new RoutingError(`workflow "${definition.name}": step "${step.name}" onFailure threw`, {
+			stepName: step.name,
+			cause: err
+		});
+	}
+	return mapNextStep(outcome);
+}
+function resolveInitialStep(definition, resumeFrom) {
+	if (!resumeFrom) return definition.steps[0]?.name ?? null;
+	if (resumeFrom.next && definition.steps.some((s) => s.name === resumeFrom.next)) return resumeFrom.next;
+	for (const step of definition.steps) {
+		const snap = resumeFrom.steps[step.name];
+		if (!snap || snap.status !== "completed" && snap.status !== "skipped") return step.name;
+	}
+	return null;
+}
+async function validateWorkflowOutput(schema, value) {
+	if (!schema) return value;
+	const result = await schema["~standard"].validate(value);
+	if (result && typeof result === "object" && "issues" in result && result.issues) throw new SchemaValidationError("workflow output failed schema validation", { issues: result.issues });
+	return result.value;
+}
+
+//#endregion
+export { runWorkflow };
+//# sourceMappingURL=engine.mjs.map

package/esm/workflow/engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/workflow/engine.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport type { BaseReport } from \"../contracts/result/base-report.type\";\nimport type { StepSnapshot } from \"../contracts/result/step-result.type\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport type {\n  WorkflowReport,\n  WorkflowResult,\n} from \"../contracts/result/workflow-result.type\";\nimport type { StepDefinition } from \"../contracts/workflow/step.contract\";\nimport type { WorkflowContext } from \"../contracts/workflow/workflow-context.type\";\nimport type { WorkflowSnapshot } from \"../contracts/workflow/workflow-snapshot.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowEventHandlers,\n} from \"../contracts/workflow/workflow.contract\";\nimport {\n  AIError,\n  MaxStepsExceededError,\n  RoutingError,\n  SchemaValidationError,\n  WorkflowCancelledError,\n  WorkflowError,\n} from \"../errors\";\nimport { stampReportLineage } from \"../utils\";\nimport { createCancelledError } from \"./cancellation\";\nimport type { WorkflowEmitter } from \"./emitter\";\nimport { mapNextStep, nextDeclaredStep, resolveNextStep } from \"./router\";\nimport { runScopedEmitter } from \"./run-scoped-emitter\";\nimport { persistSnapshot } from \"./snapshot\";\nimport { cloneState, deepFreeze } from \"./state\";\nimport { executeStep, finalizeSnapshot, toAIError } from \"./step-runner\";\n\nexport { loadSnapshotForResume } from \"./snapshot\";\n\nconst DEFAULT_MAX_STEPS = 100;\nconst DEFAULT_LOOP_WARN = 5;\nconst LOG_MODULE_BASE = \"ai.workflow\";\n\ntype EngineParams<TOutput> = {\n  definition: WorkflowDefinition<any, TOutput, any, any>;\n  signature: string;\n  emitter: WorkflowEmitter;\n  input: unknown;\n  /**\n   * Request-scoped envelope, frozen and exposed as `ctx.context` to\n   * every step. Never persisted in snapshots; resume callers supply\n   * it fresh via `WorkflowResumeOptions.context`. Defaults to a\n   * frozen empty object when caller omits it.\n   */\n  context?: unknown;\n  runId: string;\n  signal?: AbortSignal;\n  executionHandlers?: WorkflowEventHandlers;\n  resumeFrom?: WorkflowSnapshot;\n  /**\n   * Opaque session identifier propagated onto every report node this\n   * run produces — including agent reports from child steps. Threaded\n   * from `WorkflowRunOptions.sessionId`. Omitted leaves the field\n   * undefined throughout the tree.\n   */\n  sessionId?: string;\n};\n\n/**\n * Main workflow driver. Walks the declared steps, handling routing,\n * cancellation, retries, parallel execution, and snapshot\n * persistence. Delegates the step lifecycle to `step-runner.ts`,\n * routing to `router.ts`, persistence to `snapshot.ts`. Never throws\n * — every failure funnels into `result.error`.\n */\nexport async function runWorkflow<TOutput>(\n  params: EngineParams<TOutput>,\n): Promise<WorkflowResult<TOutput>> {\n  const { definition, signature, input, runId, signal } = params;\n  // Bind the factory-scoped emitter to THIS run's identity. Every\n  // `emitter.emit(...)` below — and the one threaded into\n  // `executeStep` — now stamps `runId` / `rootRunId` automatically.\n  const emitter = runScopedEmitter(params.emitter, {\n    runId,\n    rootRunId: runId,\n  });\n\n  // Freeze the envelope once at run start. Default to `{}` so step\n  // code can always read `ctx.context` without an undefined guard.\n  const context = Object.freeze(params.context ?? {});\n  const maxSteps = definition.maxSteps ?? DEFAULT_MAX_STEPS;\n  const loopWarnAfter = definition.loopWarnAfter ?? DEFAULT_LOOP_WARN;\n\n  const logger = log;\n  const logModule = `${LOG_MODULE_BASE}.${definition.name}`;\n\n  const stepByName = new Map<string, StepDefinition>();\n  for (const s of definition.steps) stepByName.set(s.name, s);\n\n  const state: Record<string, unknown> = params.resumeFrom\n    ? { ...params.resumeFrom.state }\n    : {};\n  const steps: Record<string, StepSnapshot> = params.resumeFrom\n    ? { ...params.resumeFrom.steps }\n    : {};\n  const enteredCount = new Map<string, number>();\n  const usage: Usage = { input: 0, output: 0, total: 0 };\n\n  const startedAt = params.resumeFrom?.startedAt ?? new Date().toISOString();\n  const startedAtDate = new Date(startedAt);\n  const runStartPerf = performance.now();\n\n  let error: AIError | undefined;\n  let status: \"completed\" | \"failed\" | \"cancelled\" = \"completed\";\n  let cancelledAt: string | undefined;\n  let lastGoto: string | null = null;\n  // Captured when a step throws after retries exhaust (and `onFailure`\n  // didn't recover). Used to point the final snapshot's `next` at the\n  // failed step so `resume()` re-runs it after the cause is fixed.\n  let failedStepName: string | undefined;\n\n  const buildContext = (current?: {\n    state: Record<string, unknown>;\n    agentResult?: unknown;\n  }): WorkflowContext => ({\n    input,\n    context,\n    steps: steps as Readonly<Record<string, StepSnapshot>>,\n    state: current?.state ?? state,\n    agentResult: current?.agentResult as WorkflowContext[\"agentResult\"],\n    runId,\n    signal,\n    startedAt: startedAtDate,\n  });\n\n  emitter.emit(\n    \"workflow.starting\",\n    { workflowName: definition.name, input },\n    params.executionHandlers,\n  );\n  logger.info(logModule, \"starting\", \"workflow starting\", { runId });\n\n  let currentName: string | null = resolveInitialStep(\n    definition,\n    params.resumeFrom,\n  );\n  let stepCount = 0;\n\n  try {\n    while (currentName !== null) {\n      if (signal?.aborted) throw createCancelledError(signal);\n\n      stepCount += 1;\n      if (stepCount > maxSteps) {\n        throw new MaxStepsExceededError(\n          `workflow \"${definition.name}\" exceeded maxSteps=${maxSteps}`,\n          { maxSteps },\n        );\n      }\n\n      const entered = (enteredCount.get(currentName) ?? 0) + 1;\n      enteredCount.set(currentName, entered);\n      if (entered === loopWarnAfter) {\n        emitter.emit(\n          \"workflow.loop.warning\",\n          { step: currentName, enteredCount: entered, lastGoto },\n          params.executionHandlers,\n        );\n        logger.warn(logModule, \"loop.warning\", \"loop warning\", {\n          step: currentName,\n          enteredCount: entered,\n        });\n      }\n\n      const step = stepByName.get(currentName);\n      if (!step) {\n        throw new RoutingError(\n          `workflow \"${definition.name}\": unknown step \"${currentName}\"`,\n          { stepName: currentName },\n        );\n      }\n\n      const snapshot = await executeStep({\n        step,\n        state,\n        emitter,\n        executionHandlers: params.executionHandlers,\n        logger,\n        logModule,\n        signal,\n        buildContext,\n        usage,\n        workflowDefaultRetry: definition.defaultRetry,\n      });\n\n      Object.assign(state, snapshot.state);\n      steps[step.name] = finalizeSnapshot(snapshot);\n      // Parallel children — flat-path addressing alongside nested.\n      if (snapshot.steps) {\n        for (const [childName, childSnap] of Object.entries(snapshot.steps)) {\n          steps[childName] = childSnap;\n        }\n      }\n\n      // Failure path: retries exhausted. Give `onFailure` a chance to\n      // recover; otherwise checkpoint at the failed step (so resume\n      // re-runs it) and throw — workflow halts.\n      if (snapshot.status === \"failed\" && snapshot.error) {\n        const failureRoute = await resolveFailureRoute({\n          step,\n          definition,\n          error: snapshot.error,\n          ctx: buildContext({ state, agentResult: snapshot.executionResult }),\n        });\n\n        if (failureRoute === undefined) {\n          // No recovery — persist with `next: step.name` so resume\n          // re-runs this step after the user fixes the cause.\n          const persistOutcome = await persistSnapshot({\n            definition,\n            signature,\n            runId,\n            startedAt,\n            input,\n            state,\n            steps,\n            next: step.name,\n            status: \"running\",\n          });\n          if (!persistOutcome.ok) {\n            const persistErr = toAIError(persistOutcome.error);\n            emitter.emit(\n              \"workflow.error\",\n              { error: persistErr },\n              params.executionHandlers,\n            );\n            logger.error(\n              logModule,\n              \"persist.failed\",\n              \"snapshot persist failed\",\n              {\n                step: step.name,\n                code: persistErr.code,\n                message: persistErr.message,\n              },\n            );\n          }\n          failedStepName = step.name;\n          throw snapshot.error;\n        }\n\n        // onFailure routed — workflow continues. Checkpoint at the\n        // routed target (or `null` for `end`) so resume picks up there.\n        const failureNext = failureRoute === \"end\" ? null : failureRoute;\n        if (failureNext !== null && !stepByName.has(failureNext)) {\n          throw new RoutingError(\n            `workflow \"${definition.name}\": step \"${step.name}\" onFailure routed to unknown target \"${failureNext}\"`,\n            { stepName: step.name, targetName: failureNext },\n          );\n        }\n\n        const failurePersist = await persistSnapshot({\n          definition,\n          signature,\n          runId,\n          startedAt,\n          input,\n          state,\n          steps,\n          next: failureNext,\n          status: \"running\",\n        });\n        if (!failurePersist.ok) {\n          const persistErr = toAIError(failurePersist.error);\n          emitter.emit(\n            \"workflow.error\",\n            { error: persistErr },\n            params.executionHandlers,\n          );\n          logger.error(\n            logModule,\n            \"persist.failed\",\n            \"snapshot persist failed\",\n            {\n              step: step.name,\n              code: persistErr.code,\n              message: persistErr.message,\n            },\n          );\n        }\n\n        if (signal?.aborted) throw createCancelledError(signal);\n\n        if (failureRoute === \"end\") {\n          currentName = null;\n          break;\n        }\n\n        lastGoto = failureRoute;\n        currentName = failureRoute;\n        continue;\n      }\n\n      // Resolve next step for checkpoint accuracy BEFORE routing errors\n      // bubble — so the snapshot records where resume should resume from.\n      const resolved = await resolveNextStep({\n        step,\n        definition,\n        ctx: buildContext({ state, agentResult: snapshot.executionResult }),\n      });\n\n      const nextName =\n        resolved === \"end\"\n          ? null\n          : typeof resolved === \"string\"\n            ? resolved\n            : nextDeclaredStep(definition, step.name);\n\n      // Checkpoint after every step with the resolved `next`.\n      const outcome = await persistSnapshot({\n        definition,\n        signature,\n        runId,\n        startedAt,\n        input,\n        state,\n        steps,\n        next: nextName,\n        status: \"running\",\n      });\n      if (!outcome.ok) {\n        const persistErr = toAIError(outcome.error);\n        emitter.emit(\n          \"workflow.error\",\n          { error: persistErr },\n          params.executionHandlers,\n        );\n        logger.error(logModule, \"persist.failed\", \"snapshot persist failed\", {\n          step: step.name,\n          code: persistErr.code,\n          message: persistErr.message,\n        });\n      }\n\n      if (signal?.aborted) throw createCancelledError(signal);\n\n      if (resolved === \"end\") {\n        currentName = null;\n        break;\n      }\n\n      if (typeof resolved === \"string\") {\n        if (!stepByName.has(resolved)) {\n          throw new RoutingError(\n            `workflow \"${definition.name}\": step \"${step.name}\" goto unknown target \"${resolved}\"`,\n            { stepName: step.name, targetName: resolved },\n          );\n        }\n        lastGoto = resolved;\n        currentName = resolved;\n        continue;\n      }\n\n      currentName = nextName;\n      lastGoto = currentName;\n    }\n  } catch (err) {\n    if (err instanceof WorkflowCancelledError) {\n      status = \"cancelled\";\n      cancelledAt = err.cancelledAt;\n      error = err;\n    } else if (err instanceof AIError) {\n      status = \"failed\";\n      error = err;\n    } else {\n      status = \"failed\";\n      error = new WorkflowError(\n        err instanceof Error ? err.message : String(err),\n        { cause: err },\n      );\n    }\n  }\n\n  // Note: a `failed` step always throws (caught above) unless its\n  // `onFailure` recovered the run. A `completed` workflow may still\n  // contain `failed` step snapshots — those are the recovered cases\n  // and are intentionally preserved for forensic trace.\n\n  const endedAt = new Date().toISOString();\n  const duration = performance.now() - runStartPerf;\n\n  let data: TOutput | undefined;\n  if (status === \"completed\" && definition.output) {\n    try {\n      const extracted = await definition.output.extract(\n        buildContext({ state }),\n      );\n      data = (await validateWorkflowOutput(\n        definition.output.schema,\n        extracted,\n      )) as TOutput;\n    } catch (err) {\n      status = \"failed\";\n      error =\n        err instanceof AIError\n          ? err\n          : new WorkflowError(\n              err instanceof Error ? err.message : String(err),\n              { cause: err },\n            );\n    }\n  }\n\n  // Collect child executable reports from every step that ran one.\n  // Today the step runner surfaces agent reports (the only executable\n  // kind steps can invoke natively via `step.agent`); custom `run`\n  // callbacks that call tools/workflows/supervisors can't be observed\n  // here without a richer step-runner API — that's a v1.x follow-up\n  // (see backlog: \"step.run executables surface in workflow tree\").\n  const children: BaseReport[] = [];\n  for (const stepName in steps) {\n    const snap = steps[stepName];\n    if (snap.agentReport) {\n      children.push(snap.agentReport);\n    }\n  }\n\n  const report: WorkflowReport = {\n    runId,\n    rootRunId: runId,\n    name: definition.name,\n    version: definition.version,\n    type: \"workflow\",\n    workflowName: definition.name,\n    signature,\n    status,\n    startedAt,\n    endedAt,\n    duration,\n    cancelledAt,\n    usage,\n    children,\n    steps,\n    state: deepFreeze(cloneState(state)),\n  };\n\n  // Stamp lineage on the assembled tree exactly once. Walker rewrites\n  // any inner self-roots that nested agent reports brought in (each\n  // agent's `buildResult` set its own runId as root), propagates\n  // sessionId, and writes `reportSchemaVersion` on the root.\n  stampReportLineage(report, {\n    rootRunId: runId,\n    sessionId: params.sessionId,\n  });\n\n  // On a failed run with a captured `failedStepName`, point `next` at\n  // the failed step so `resume()` re-runs it. The pre-throw checkpoint\n  // already wrote this value, but the final snapshot would otherwise\n  // overwrite it with `null` and force resume to fall back to the\n  // first non-completed step (which is the same step in practice, but\n  // less informative for tooling reading the snapshot).\n  const finalNext = status === \"failed\" ? failedStepName ?? null : null;\n\n  const finalOutcome = await persistSnapshot({\n    definition,\n    signature,\n    runId,\n    startedAt,\n    input,\n    state,\n    steps,\n    next: finalNext,\n    status,\n  });\n  if (!finalOutcome.ok) {\n    const persistErr = toAIError(finalOutcome.error);\n    emitter.emit(\n      \"workflow.error\",\n      { error: persistErr },\n      params.executionHandlers,\n    );\n    logger.error(logModule, \"persist.failed\", \"final snapshot persist failed\", {\n      code: persistErr.code,\n      message: persistErr.message,\n    });\n  }\n\n  const result: WorkflowResult<TOutput> = {\n    type: \"workflow\",\n    data,\n    report,\n    usage,\n    error,\n  };\n\n  if (status === \"cancelled\") {\n    emitter.emit(\n      \"workflow.cancelled\",\n      {\n        cancelledAt: cancelledAt ?? endedAt,\n        reason: (error as WorkflowCancelledError | undefined)?.reason ?? \"\",\n      },\n      params.executionHandlers,\n    );\n    logger.warn(logModule, \"cancelled\", \"workflow cancelled\", { runId });\n  }\n\n  if (status === \"failed\" && error) {\n    emitter.emit(\"workflow.error\", { error }, params.executionHandlers);\n    logger.error(logModule, \"error\", \"workflow failed\", {\n      runId,\n      code: error.code,\n      message: error.message,\n    });\n  }\n\n  emitter.emit(\n    \"workflow.completed\",\n    { result: result as WorkflowResult<unknown> },\n    params.executionHandlers,\n  );\n  logger.info(logModule, \"completed\", \"workflow completed\", {\n    runId,\n    status,\n    duration,\n  });\n\n  return result;\n}\n\n/**\n * Run a failed step's `onFailure` hook (if present) and translate its\n * result into a route. Returns `undefined` when the workflow should\n * halt with the original error; `\"end\"` for clean termination; or a\n * step name to redirect to. A throw inside `onFailure` is wrapped in\n * `RoutingError` — routing is authoritative, never retried.\n */\nasync function resolveFailureRoute<T>(params: {\n  step: StepDefinition;\n  definition: WorkflowDefinition<any, T, any, any>;\n  error: AIError;\n  ctx: WorkflowContext;\n}): Promise<\"end\" | string | undefined> {\n  const { step, definition, error, ctx } = params;\n  if (!step.onFailure) return undefined;\n\n  let outcome;\n  try {\n    outcome = await step.onFailure(ctx, error);\n  } catch (err) {\n    throw new RoutingError(\n      `workflow \"${definition.name}\": step \"${step.name}\" onFailure threw`,\n      { stepName: step.name, cause: err },\n    );\n  }\n  return mapNextStep(outcome);\n}\n\nfunction resolveInitialStep<T>(\n  definition: WorkflowDefinition<any, T, any, any>,\n  resumeFrom: WorkflowSnapshot | undefined,\n): string | null {\n  if (!resumeFrom) return definition.steps[0]?.name ?? null;\n\n  // Prefer the explicitly-recorded `next` (now populated on every\n  // checkpoint). Falls back to first step whose snapshot is missing\n  // or not in a terminal-success state — covers older snapshots\n  // written before `next` was wired.\n  if (\n    resumeFrom.next &&\n    definition.steps.some(s => s.name === resumeFrom.next)\n  ) {\n    return resumeFrom.next;\n  }\n\n  for (const step of definition.steps) {\n    const snap = resumeFrom.steps[step.name];\n    if (!snap || (snap.status !== \"completed\" && snap.status !== \"skipped\")) {\n      return step.name;\n    }\n  }\n\n  return null;\n}\n\nasync function validateWorkflowOutput(\n  schema: unknown,\n  value: unknown,\n): Promise<unknown> {\n  if (!schema) return value;\n\n  const result = await (\n    schema as {\n      \"~standard\": { validate: (v: unknown) => Promise<unknown> | unknown };\n    }\n  )[\"~standard\"].validate(value);\n\n  if (\n    result &&\n    typeof result === \"object\" &&\n    \"issues\" in result &&\n    (result as { issues: unknown }).issues\n  ) {\n    throw new SchemaValidationError(\n      \"workflow output failed schema validation\",\n      {\n        issues: (result as { issues: any }).issues,\n      },\n    );\n  }\n\n  return (result as { value: unknown }).value;\n}\n"],"mappings":"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"}

package/esm/workflow/index.d.mts

@@ -0,0 +1,3 @@
+import { step } from "./step.mjs";
+import { workflow } from "./workflow.mjs";
+import { computeSignature } from "./signature.mjs";

package/esm/workflow/index.mjs

@@ -0,0 +1,5 @@
+import { step } from "./step.mjs";
+import { computeSignature } from "./signature.mjs";
+import { workflow } from "./workflow.mjs";
+
+export {  };

package/esm/workflow/retry.mjs

@@ -0,0 +1,32 @@
+//#region ../../@warlock.js/ai/src/workflow/retry.ts
+const DEFAULT_BACKOFF_CAP_MS = 3e4;
+function resolveBackoff(attempt, backoff) {
+	const value = (() => {
+		switch (backoff) {
+			case "none": return 0;
+			case "linear": return attempt * 500;
+			case "exponential":
+			case void 0: return 500 * 2 ** (attempt - 1);
+			default: return backoff(attempt);
+		}
+	})();
+	return Math.max(0, Math.min(value, DEFAULT_BACKOFF_CAP_MS));
+}
+function isAbortError(error) {
+	if (!error || typeof error !== "object") return false;
+	return error.name === "AbortError";
+}
+/**
+* Resolve the effective retry config for a step, merging per-step and
+* workflow-level defaults. `retry: false` disables retries entirely.
+*/
+function resolveRetryConfig(step, workflowDefault) {
+	if (step?.retry === false) return { attempts: 1 };
+	if (step?.retry) return step.retry;
+	if (workflowDefault === false || workflowDefault === void 0) return { attempts: 1 };
+	return workflowDefault;
+}
+
+//#endregion
+export { isAbortError, resolveBackoff, resolveRetryConfig };
+//# sourceMappingURL=retry.mjs.map

package/esm/workflow/retry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/workflow/retry.ts"],"sourcesContent":["import type {\n  RetryBackoff,\n  RetryConfig,\n} from \"../contracts/workflow/retry-config.type\";\n\nexport const DEFAULT_BACKOFF_CAP_MS = 30_000;\n\nexport function resolveBackoff(\n  attempt: number,\n  backoff: RetryBackoff | undefined,\n): number {\n  const value = (() => {\n    switch (backoff) {\n      case \"none\":\n        return 0;\n      case \"linear\":\n        return attempt * 500;\n      case \"exponential\":\n      case undefined:\n        return 500 * 2 ** (attempt - 1);\n      default:\n        return backoff(attempt);\n    }\n  })();\n\n  return Math.max(0, Math.min(value, DEFAULT_BACKOFF_CAP_MS));\n}\n\nexport function isAbortError(error: unknown): boolean {\n  if (!error || typeof error !== \"object\") return false;\n  const name = (error as { name?: unknown }).name;\n  return name === \"AbortError\";\n}\n\n/**\n * Resolve the effective retry config for a step, merging per-step and\n * workflow-level defaults. `retry: false` disables retries entirely.\n */\nexport function resolveRetryConfig(\n  step: { retry?: RetryConfig | false } | undefined,\n  workflowDefault: RetryConfig | false | undefined,\n): RetryConfig {\n  if (step?.retry === false) return { attempts: 1 };\n  if (step?.retry) return step.retry;\n  if (workflowDefault === false || workflowDefault === undefined) {\n    return { attempts: 1 };\n  }\n  return workflowDefault;\n}\n"],"mappings":";AAKA,MAAa,yBAAyB;AAEtC,SAAgB,eACd,SACA,SACQ;CACR,MAAM,eAAe;EACnB,QAAQ,SAAR;GACE,KAAK,QACH,OAAO;GACT,KAAK,UACH,OAAO,UAAU;GACnB,KAAK;GACL,KAAK,QACH,OAAO,MAAM,MAAM,UAAU;GAC/B,SACE,OAAO,QAAQ,OAAO;EAC1B;CACF,GAAG;CAEH,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,OAAO,sBAAsB,CAAC;AAC5D;AAEA,SAAgB,aAAa,OAAyB;CACpD,IAAI,CAAC,SAAS,OAAO,UAAU,UAAU,OAAO;CAEhD,OADc,MAA6B,SAC3B;AAClB;;;;;AAMA,SAAgB,mBACd,MACA,iBACa;CACb,IAAI,MAAM,UAAU,OAAO,OAAO,EAAE,UAAU,EAAE;CAChD,IAAI,MAAM,OAAO,OAAO,KAAK;CAC7B,IAAI,oBAAoB,SAAS,oBAAoB,QACnD,OAAO,EAAE,UAAU,EAAE;CAEvB,OAAO;AACT"}