@voltro/plugin-ai-flows 0.85.0 → 0.87.0

package/dist/{cadence-_9Izk_fL.js → cadence.js}

@@ -37,4 +37,4 @@ var e = (e) => (e.getDay() + 6) % 7, t = (e) => Math.ceil(e.getDate() / 7), n =
 	return r;
 };
 //#endregion
-export { o as n, a as t };
+export { a as cadenceMatches, o as nextRuns };

package/dist/cadenceTick.js

@@ -0,0 +1,80 @@
+import { listRegisteredFlows as e } from "./registry.js";
+import { flowRunWorkflow as t } from "./workflow.js";
+import { reconcileFlowStarts as n } from "./startReconcile.js";
+import { cadenceMatches as r } from "./cadence.js";
+import { recordFlowStartReceipt as i } from "./startReceipt.js";
+import { Schema as a } from "effect";
+import { createHash as o } from "node:crypto";
+//#region src/cadenceTick.ts
+var s = (e, t, n) => {
+	if (!Number.isFinite(t.getTime())) throw Error("cadence timestamp must be valid");
+	return `cron-${o("sha256").update(JSON.stringify([
+		n,
+		e,
+		Math.floor(t.getTime() / 6e4)
+	])).digest("hex")}`;
+}, c = async (t) => {
+	let n = [];
+	for (let r of e()) r.cadence && (r.cadence.repeats?.length ?? 0) > 0 && n.push({
+		tenantId: t.request.subject.tenantId,
+		flowRef: r.name,
+		cadence: r.cadence,
+		defaultInput: r.cadence.defaultInput ?? {}
+	});
+	let r = await t.store.select("_voltro_ai_flows").where("isEnabled", !0).all();
+	for (let e of r) e.id && e.cadence && (e.cadence.repeats?.length ?? 0) > 0 && n.push({
+		tenantId: e.tenantId ?? t.request.subject.tenantId,
+		flowRef: e.id,
+		cadence: e.cadence,
+		defaultInput: e.cadence.defaultInput ?? {}
+	});
+	return n;
+}, l = async (e, o = /* @__PURE__ */ new Date()) => {
+	let l = [], u = 0, d = [], f = e.workflows ? await n(e) : {
+		examined: 0,
+		accepted: 0,
+		notExecuted: 0,
+		pending: 0,
+		failures: []
+	};
+	d.push(...f.failures.map((e) => Error(`flow run ${e.runId}: start reconciliation failed`, { cause: e.cause })));
+	let p = await c(e);
+	for (let n of p) {
+		if (!r(n.cadence, o)) continue;
+		u += 1;
+		let c = s(n.flowRef, o, n.tenantId), f = `run-${c}`;
+		try {
+			if (!e.workflows) throw Error("workflow runtime unavailable; no cadence start was submitted");
+			(await e.transaction(async (e) => {
+				let r = e.workflows;
+				if (!r) throw Error("workflow runtime unavailable in transaction; no cadence start was submitted");
+				await e.store.insertIgnoreWithOutcome("_voltro_ai_flow_runs", {
+					id: f,
+					flowRef: n.flowRef,
+					flowName: n.flowRef,
+					status: "pending",
+					source: "cron",
+					requestId: c,
+					input: n.defaultInput
+				}, { conflictColumns: ["id"] });
+				let o = await e.store.select("_voltro_ai_flow_runs").where("id", f).first();
+				if (!o) throw Error("cadence run is not readable after persistence");
+				let s = a.decodeUnknownSync(t.payloadSchema.pipe(a.check(a.makeFilter((e) => e.runId === f && e.flowRef === n.flowRef && e.requestId === c && e.source === "cron"))))({
+					...o,
+					runId: o.id
+				});
+				return i(e, f, await r.start("flow.run", s));
+			}, n.tenantId === null ? void 0 : { tenantId: n.tenantId })).status === "running" && l.push(c);
+		} catch (e) {
+			d.push(e);
+		}
+	}
+	if (d.length > 0) throw AggregateError(d, `${d.length} cadence submission(s) failed`);
+	return {
+		matched: u,
+		started: l,
+		reconciled: f
+	};
+};
+//#endregion
+export { s as cronRequestId, l as runCadenceTick };

package/dist/condition.js

@@ -0,0 +1,46 @@
+import { Schema as e } from "effect";
+//#region src/condition.ts
+var t = e.Literals([
+	"truthy",
+	"falsy",
+	"eq",
+	"neq",
+	"contains"
+]), n = e.Struct({
+	ref: e.String,
+	op: t,
+	value: e.optional(e.Unknown)
+}), r = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, i = (e, t) => {
+	if (e === t) return !0;
+	if (e === null || t === null || e === void 0 || t === void 0) return !1;
+	if (typeof e == "object" || typeof t == "object") try {
+		return JSON.stringify(e) === JSON.stringify(t);
+	} catch {
+		return !1;
+	}
+	return String(e) === String(t);
+}, a = (e, t) => {
+	let n = t[e.ref];
+	switch (e.op) {
+		case "truthy": return r(n);
+		case "falsy": return !r(n);
+		case "eq": return i(n, e.value);
+		case "neq": return !i(n, e.value);
+		case "contains": {
+			if (n == null) return !1;
+			if (Array.isArray(n)) return n.some((t) => i(t, e.value));
+			let t = e.value;
+			return typeof t != "string" && typeof t != "number" ? !1 : String(n).includes(String(t));
+		}
+	}
+}, o = (e) => {
+	switch (e.op) {
+		case "truthy": return `{{${e.ref}}} is set`;
+		case "falsy": return `{{${e.ref}}} is not set`;
+		case "eq": return `{{${e.ref}}} equals ${JSON.stringify(e.value)}`;
+		case "neq": return `{{${e.ref}}} does not equal ${JSON.stringify(e.value)}`;
+		case "contains": return `{{${e.ref}}} contains ${JSON.stringify(e.value)}`;
+	}
+};
+//#endregion
+export { t as ConditionOp, n as StepCondition, o as describeCondition, a as evaluateCondition, r as isTruthy };

package/dist/defaults.js

@@ -0,0 +1,18 @@
+//#region src/defaults.ts
+var e = 168, t = "VOLTRO_AI_FLOW_HUMAN_REVIEW_TIMEOUT_HOURS", n = 2160, r = "VOLTRO_AI_FLOW_RUNS_TTL_HOURS", i = 5, a = "VOLTRO_AI_FLOW_MAX_CHAIN_DEPTH", o = { current: {} }, s = (e) => {
+	o.current = e;
+}, c = () => o.current, l = () => {
+	o.current = {};
+}, u = (e, t) => {
+	if (e === void 0 || e.trim() === "") return t * 36e5;
+	let n = Number(e);
+	return !Number.isFinite(n) || n < 0 ? t * 36e5 : n * 36e5;
+}, d = (e) => Number.isFinite(e) && e > 0 ? e : Infinity, f = (e) => {
+	let t = e.env ?? process.env;
+	return d(e.step?.timeoutMs ?? e.flow?.humanTimeoutMs ?? e.deps?.humanReviewTimeoutMs ?? c().humanReviewTimeoutMs ?? u(t.VOLTRO_AI_FLOW_HUMAN_REVIEW_TIMEOUT_HOURS, 168));
+}, p = (e) => {
+	let t = e?.env ?? process.env, n = Number(t[a]), r = e?.maxChainDepth ?? c().maxChainDepth ?? (Number.isFinite(n) && n >= 1 ? n : 5);
+	return Number.isFinite(r) && r >= 1 ? r : 5;
+};
+//#endregion
+export { r as FLOW_RUNS_TTL_ENV, n as FLOW_RUNS_TTL_HOURS_DEFAULT, t as HUMAN_REVIEW_TIMEOUT_ENV, e as HUMAN_REVIEW_TIMEOUT_HOURS_DEFAULT, i as MAX_CHAIN_DEPTH_DEFAULT, a as MAX_CHAIN_DEPTH_ENV, c as getAiFlowsDefaults, u as msFromHoursEnv, l as resetAiFlowsDefaults, f as resolveHumanReviewTimeoutMs, p as resolveMaxChainDepth, s as setAiFlowsDefaults, d as toTimeoutMs };

package/dist/define.js

@@ -0,0 +1,71 @@
+import { registerFlow as e } from "./registry.js";
+import { normalizeFlow as t, sanitizeOutputKey as n } from "./ir.js";
+import { collectRefs as r } from "./interpolate.js";
+import { flowSegments as i, nonContiguousGroups as a } from "./segments.js";
+import { FlowValidationError as o } from "./errors.js";
+//#region src/define.ts
+var s = {
+	text: (e) => ({
+		type: "generate",
+		modality: "text",
+		...e
+	}),
+	media: (e, t) => ({
+		type: "generate",
+		modality: e,
+		...t
+	}),
+	agent: (e) => ({
+		type: "agent",
+		...e
+	}),
+	structured: (e) => ({
+		type: "structured",
+		...e
+	}),
+	note: (e) => ({
+		type: "note",
+		...e
+	}),
+	human: (e) => ({
+		type: "human",
+		...e
+	})
+}, c = (e) => e.map((e, t) => "id" in e && e.id ? e : {
+	id: `step-${t}`,
+	...e
+}), l = (e) => {
+	let t = [], s = i(e.steps);
+	for (let e of a(s)) t.push(`group "${e}" is not contiguous — only CONSECUTIVE steps sharing a group run concurrently, so this would execute as two separate fan-outs`);
+	let c = new Set(e.brief.map((e) => e.key));
+	for (let e of s) {
+		for (let { step: n } of e.steps) {
+			n.type === "human" && n.group !== void 0 && t.push(`step "${n.id}" is a human review inside group "${n.group}" — a review SUSPENDS the whole run, which one branch of a fan-out cannot do`);
+			for (let i of r(n.prompt ?? "")) c.has(i) || t.push(e.steps.length > 1 ? `step "${n.id}" references {{${i}}} which is produced inside its OWN group "${n.group}" or does not exist — grouped steps run concurrently, so they cannot read each other` : `step "${n.id}" references {{${i}}} which is not a brief field or a prior step outputKey`);
+			for (let [e, r] of Object.entries(n.mediaInputs ?? {})) r.from === "step" && !c.has(r.ref) && t.push(`step "${n.id}" media input "${e}" references "${r.ref}" which is not a brief field or an earlier segment's outputKey`);
+			n.when !== void 0 && !c.has(n.when.ref) && t.push(`step "${n.id}" has a when-condition on {{${n.when.ref}}} which is not a brief field or a prior step outputKey — it would never run`);
+		}
+		for (let { step: t } of e.steps) t.outputKey && c.add(n(t.outputKey));
+	}
+	if (t.length > 0) throw new o({
+		flowRef: e.name,
+		message: `flow "${e.name}" has ${t.length} problem(s)`,
+		issues: t
+	});
+}, u = (n) => {
+	let r = t({
+		name: n.name,
+		mode: n.mode,
+		steps: c(n.steps),
+		maxSteps: n.maxSteps,
+		brief: n.brief,
+		orchestratorModel: n.orchestrator?.model,
+		orchestratorInstructions: n.orchestrator?.instructions,
+		chain: n.chain,
+		cadence: n.cadence,
+		humanTimeoutMs: n.humanTimeoutMs
+	});
+	return l(r), e(r), r;
+};
+//#endregion
+export { u as defineFlow, s as flowStep, l as validateFlow };