@voltro/plugin-ai-flows 0.75.0 → 0.76.0

package/dist/{ir-C2ewescS.js → ir-BW5JRUiH.js}

@@ -1,11 +1,11 @@
 import { Schema as e } from "effect";
-import { WorkflowRunHandleSchema as t } from "@voltro/protocol";
+import { WorkflowControlResultSchema as t, WorkflowRunHandleSchema as n } from "@voltro/protocol";
 //#region src/condition.ts
-var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
+var r = e.Literal("truthy", "falsy", "eq", "neq", "contains"), i = e.Struct({
 	ref: e.String,
-	op: n,
+	op: r,
 	value: e.optional(e.Unknown)
-}), i = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, a = (e, t) => {
+}), a = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, o = (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 {
@@ -14,21 +14,21 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		return !1;
 	}
 	return String(e) === String(t);
-}, o = (e, t) => {
+}, s = (e, t) => {
 	let n = t[e.ref];
 	switch (e.op) {
-		case "truthy": return i(n);
-		case "falsy": return !i(n);
-		case "eq": return a(n, e.value);
-		case "neq": return !a(n, e.value);
+		case "truthy": return a(n);
+		case "falsy": return !a(n);
+		case "eq": return o(n, e.value);
+		case "neq": return !o(n, e.value);
 		case "contains": {
 			if (n == null) return !1;
-			if (Array.isArray(n)) return n.some((t) => a(t, e.value));
+			if (Array.isArray(n)) return n.some((t) => o(t, e.value));
 			let t = e.value;
 			return typeof t != "string" && typeof t != "number" ? !1 : String(n).includes(String(t));
 		}
 	}
-}, s = (e) => {
+}, c = (e) => {
 	switch (e.op) {
 		case "truthy": return `{{${e.ref}}} is set`;
 		case "falsy": return `{{${e.ref}}} is not set`;
@@ -36,14 +36,30 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		case "neq": return `{{${e.ref}}} does not equal ${JSON.stringify(e.value)}`;
 		case "contains": return `{{${e.ref}}} contains ${JSON.stringify(e.value)}`;
 	}
-}, c = e.Struct({
+}, l = e.Struct({
 	runId: e.NonEmptyString,
 	requestId: e.NonEmptyString,
-	admission: t
-}), l = e.Literal("deterministic", "agentic"), u = e.Literal("draft", "active", "archived"), d = e.Literal("private", "organization", "shared"), f = e.Literal("pending", "running", "waiting", "succeeded", "failed", "cancelled"), p = e.Literal("manual", "cron"), m = e.Literal("agent", "generate", "structured", "note", "human"), h = e.Literal("text", "image", "video", "audio"), g = e.Literal("approve", "choice", "text"), _ = e.Struct({
+	admission: n
+}), u = e.Literal("deterministic", "agentic"), d = e.Literal("draft", "active", "archived"), f = e.Literal("private", "organization", "shared"), p = e.Literal("pending", "running", "waiting", "succeeded", "failed", "cancelled"), m = e.Struct({
+	runId: e.NonEmptyString,
+	status: p,
+	engine: e.Literal("cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"),
+	control: e.NullOr(t)
+}).pipe(e.filter((e) => {
+	let t = e.control;
+	if (t !== null && t.operation !== "cancel") return !1;
+	switch (e.engine) {
+		case "cancelled": return t !== null && t.snapshot.status === "cancelled" && (t.kind === "confirmed" || t.kind === "already-terminal");
+		case "accepted": return t?.kind === "accepted";
+		case "already-terminal": return t?.kind === "already-terminal" && t.snapshot.status !== "cancelled";
+		case "unknown": return t === null || t.kind === "unknown";
+		case "unreachable":
+		case "not-requested": return t === null;
+	}
+}, { message: () => "Flow cancellation acknowledgement contradicts its workflow control receipt" })), h = e.Literal("manual", "cron"), g = e.Literal("agent", "generate", "structured", "note", "human"), _ = e.Literal("text", "image", "video", "audio"), v = e.Literal("approve", "choice", "text"), y = e.Struct({
 	value: e.String,
 	label: e.String
-}), v = e.Union(e.Struct({
+}), b = e.Union(e.Struct({
 	from: e.Literal("upload"),
 	url: e.String,
 	mediaType: e.optional(e.NonEmptyString)
@@ -51,50 +67,50 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	from: e.Literal("step"),
 	ref: e.String,
 	artifact: e.optional(e.Int.pipe(e.nonNegative()))
-})), y = e.Record({
+})), x = e.Record({
 	key: e.String,
-	value: v
-}), b = e.Record({
+	value: b
+}), S = e.Record({
 	key: e.String,
 	value: e.Unknown
-}), x = e.Struct({
+}), C = e.Struct({
 	url: e.NonEmptyString,
 	mediaType: e.NonEmptyString,
 	role: e.NonEmptyString,
 	storageRefId: e.optional(e.NonEmptyString),
 	providerMetadata: e.optional(e.Unknown)
-}), S = e.Array(x).pipe(e.filter((e) => e.filter((e) => e.role === "primary").length === 1)), C = e.Struct({
+}), w = e.Array(C).pipe(e.filter((e) => e.filter((e) => e.role === "primary").length === 1)), T = e.Struct({
 	id: e.String,
 	title: e.optional(e.String),
 	description: e.optional(e.String),
-	type: m,
+	type: g,
 	outputKey: e.optional(e.String),
 	prompt: e.optional(e.String),
-	modality: e.optional(h),
+	modality: e.optional(_),
 	model: e.optional(e.String),
-	params: e.optional(b),
-	mediaInputs: e.optional(y),
+	params: e.optional(S),
+	mediaInputs: e.optional(x),
 	agentRef: e.optional(e.String),
-	schema: e.optional(b),
-	reviewMode: e.optional(g),
-	options: e.optional(e.Array(_)),
-	when: e.optional(r),
+	schema: e.optional(S),
+	reviewMode: e.optional(v),
+	options: e.optional(e.Array(y)),
+	when: e.optional(i),
 	group: e.optional(e.String),
 	timeoutMs: e.optional(e.Number)
-}), w = e.Struct({
+}), E = e.Struct({
 	key: e.String,
 	label: e.String,
 	type: e.Literal("text", "textarea", "number", "boolean"),
 	required: e.optional(e.Boolean),
 	placeholder: e.optional(e.String)
-}), T = e.Struct({
+}), D = e.Struct({
 	flowRef: e.String,
 	mappings: e.Array(e.Struct({
 		targetKey: e.String,
 		sourceKey: e.String
 	})),
 	requireConfirmation: e.optional(e.Boolean)
-}), E = e.Struct({
+}), O = e.Struct({
 	frequency: e.optional(e.Literal("weekly", "monthly")),
 	repeats: e.Array(e.Number),
 	intervalWeeks: e.optional(e.Number),
@@ -102,62 +118,62 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	weekOfMonth: e.optional(e.Union(e.Literal(1, 2, 3, 4), e.Literal("last"))),
 	hour: e.optional(e.Number),
 	minute: e.optional(e.Literal(0, 15, 30, 45)),
-	defaultInput: e.optional(b)
-}), D = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), O = e.Struct({
-	mode: g,
-	options: e.optional(e.Array(_)),
+	defaultInput: e.optional(S)
+}), k = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), A = e.Struct({
+	mode: v,
+	options: e.optional(e.Array(y)),
 	prompt: e.String
-}), k = e.Literal("gateway", "estimated", "unpriced"), A = e.Literal("actual", "estimated", "incomplete", "unknown"), j = e.Struct({
+}), j = e.Literal("gateway", "estimated", "unpriced"), M = e.Literal("actual", "estimated", "incomplete", "unknown"), N = e.Struct({
 	status: e.Literal("reported", "unreported"),
 	unit: e.optional(e.Literal("tokens", "characters", "seconds")),
 	input: e.optional(e.Finite.pipe(e.nonNegative())),
 	output: e.optional(e.Finite.pipe(e.nonNegative()))
-}), M = e.Struct({
+}), P = e.Struct({
 	costMicroUsd: e.optional(e.Finite.pipe(e.nonNegative())),
-	costSource: e.optional(k),
+	costSource: e.optional(j),
 	requestId: e.optional(e.NonEmptyString),
-	usage: e.optional(j)
-}), N = e.Struct({
+	usage: e.optional(N)
+}), F = e.Struct({
 	id: e.Number,
 	title: e.String,
 	description: e.optional(e.String),
-	type: m,
-	status: D,
+	type: g,
+	status: k,
 	startedAt: e.optional(e.String),
 	completedAt: e.optional(e.String),
 	costMicroUsd: e.optional(e.Number),
-	costSource: e.optional(k),
+	costSource: e.optional(j),
 	requestId: e.optional(e.String),
-	usage: e.optional(j),
+	usage: e.optional(N),
 	url: e.optional(e.String),
-	artifacts: e.optional(S),
+	artifacts: e.optional(w),
 	output: e.optional(e.Struct({ text: e.String })),
 	errorMessage: e.optional(e.String),
 	skipReason: e.optional(e.String),
-	review: e.optional(O)
-}), P = e.Struct({
+	review: e.optional(A)
+}), I = e.Struct({
 	decision: e.optional(e.Literal("approve", "reject")),
 	value: e.optional(e.String),
 	text: e.optional(e.String),
 	respondedAt: e.optional(e.String)
-}), F = e.Struct({
+}), L = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
-	response: P
-}), I = e.Struct({
+	response: I
+}), R = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
 	executionId: e.NonEmptyString,
 	eventId: e.NonEmptyString,
 	status: e.Literal("accepted")
-}), L = e.Struct({
+}), z = e.Struct({
 	flowRef: e.String,
-	input: b,
+	input: S,
 	status: e.Literal("pending", "confirmed", "dismissed")
-}), R = 30, z = 1, B = 100, V = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), H = (e) => e.replace(/[^\w.-]/g, "_"), U = (e) => {
+}), B = 30, V = 1, H = 100, U = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), W = (e) => e.replace(/[^\w.-]/g, "_"), G = (e) => {
 	let t = (e.steps ?? []).map((e) => e.outputKey ? {
 		...e,
-		outputKey: H(e.outputKey)
+		outputKey: W(e.outputKey)
 	} : e), n = e.orchestratorModel || e.orchestratorInstructions ? {
 		...e.orchestratorModel ? { model: e.orchestratorModel } : {},
 		...e.orchestratorInstructions ? { instructions: e.orchestratorInstructions } : {}
@@ -166,7 +182,7 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		name: e.name,
 		mode: e.mode ?? "deterministic",
 		steps: t,
-		maxSteps: V(e.maxSteps),
+		maxSteps: U(e.maxSteps),
 		brief: e.brief ?? [],
 		...n ? { orchestrator: n } : {},
 		...e.chain ? { chain: e.chain } : {},
@@ -175,4 +191,4 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	};
 };
 //#endregion
-export { D as A, o as B, h as C, p as D, O as E, U as F, H as I, n as L, j as M, d as N, f as O, V as P, r as R, M as S, _ as T, i as V, z as _, E as a, v as b, F as c, u as d, C as f, B as g, R as h, k as i, m as j, N as k, I as l, b as m, L as n, T as o, P as p, A as r, l as s, w as t, c as u, x as v, g as w, y as x, S as y, s as z };
+export { F as A, c as B, P as C, A as D, y as E, U as F, a as H, G as I, W as L, g as M, N, h as O, f as P, r as R, x as S, v as T, s as V, H as _, O as a, w as b, u as c, l as d, d as f, B as g, S as h, j as i, k as j, p as k, L as l, I as m, z as n, m as o, T as p, M as r, D as s, E as t, R as u, V as v, _ as w, b as x, C as y, i as z };

package/dist/ir.d.ts

@@ -105,6 +105,32 @@ export declare interface FlowCadence {
     readonly defaultInput?: Json | undefined;
 }
 
+/** Row state and engine acknowledgement are separate observations. Retain the
+ * control request identity so an accepted/unknown request can be observed. */
+export declare const FlowCancelReceipt: Schema.filter<Schema.Struct<{
+    runId: typeof Schema.NonEmptyString;
+    status: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "cancelled"]>;
+    engine: Schema.Literal<["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
+    control: Schema.NullOr<Schema.filter<Schema.Struct<{
+        operation: Schema.Literal<["cancel", "resume"]>;
+        kind: Schema.Literal<["accepted", "confirmed", "unknown", "already-terminal"]>;
+        requestId: Schema.NullOr<typeof Schema.NonEmptyString>;
+        snapshot: Schema.Struct<{
+            id: typeof Schema.String;
+            workflowName: typeof Schema.String;
+            executionId: typeof Schema.String;
+            status: Schema.Union<[Schema.Literal<["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<["unknown"]>]>;
+            output: Schema.optional<typeof Schema.Unknown>;
+            error: Schema.optional<Schema.Struct<{
+                tag: Schema.NullOr<typeof Schema.String>;
+                message: typeof Schema.String;
+            }>>;
+        }>;
+    }>>>;
+}>>;
+
+export declare type FlowCancelReceipt = typeof FlowCancelReceipt.Type;
+
 /** Follow-up flow spec. On success, map source → the child's brief. */
 export declare const FlowChain: Schema.Struct<{
     /** Child flow id (data) or name (code). */

package/dist/ir.js

@@ -1,2 +1,2 @@
-import { A as e, B as t, C as n, D as r, E as i, F as a, I as o, L as s, M as c, N as l, O as u, P as d, R as f, S as p, T as m, V as h, _ as g, a as _, b as v, c as y, d as b, f as x, g as S, h as C, i as w, j as T, k as E, l as D, m as O, n as k, o as A, p as j, r as M, s as N, t as P, u as F, v as I, w as L, x as R, y as z, z as B } from "./ir-C2ewescS.js";
-export { P as BriefField, k as ChainPending, s as ConditionOp, M as CostCompleteness, w as CostSource, _ as FlowCadence, A as FlowChain, N as FlowMode, y as FlowReviewInput, D as FlowReviewReceipt, F as FlowStartReceipt, b as FlowStatus, x as FlowStep, j as HumanResponse, O as Json, C as MAX_STEPS_DEFAULT, S as MAX_STEPS_MAX, g as MAX_STEPS_MIN, I as MediaArtifact, z as MediaArtifacts, v as MediaInputSlot, R as MediaInputs, p as MediaReceipt, n as Modality, L as ReviewMode, m as ReviewOption, i as RunReview, r as RunSource, u as RunStatus, E as RunStep, e as RunStepStatus, f as StepCondition, T as StepType, c as StepUsage, l as Visibility, d as clampMaxSteps, B as describeCondition, t as evaluateCondition, h as isTruthy, a as normalizeFlow, o as sanitizeOutputKey };
+import { A as e, B as t, C as n, D as r, E as i, F as a, H as o, I as s, L as c, M as l, N as u, O as d, P as f, R as p, S as m, T as h, V as g, _, a as v, b as y, c as b, d as x, f as S, g as C, h as w, i as T, j as E, k as D, l as O, m as k, n as A, o as j, p as M, r as N, s as P, t as F, u as I, v as L, w as R, x as z, y as B, z as V } from "./ir-BW5JRUiH.js";
+export { F as BriefField, A as ChainPending, p as ConditionOp, N as CostCompleteness, T as CostSource, v as FlowCadence, j as FlowCancelReceipt, P as FlowChain, b as FlowMode, O as FlowReviewInput, I as FlowReviewReceipt, x as FlowStartReceipt, S as FlowStatus, M as FlowStep, k as HumanResponse, w as Json, C as MAX_STEPS_DEFAULT, _ as MAX_STEPS_MAX, L as MAX_STEPS_MIN, B as MediaArtifact, y as MediaArtifacts, z as MediaInputSlot, m as MediaInputs, n as MediaReceipt, R as Modality, h as ReviewMode, i as ReviewOption, r as RunReview, d as RunSource, D as RunStatus, e as RunStep, E as RunStepStatus, V as StepCondition, l as StepType, u as StepUsage, f as Visibility, a as clampMaxSteps, t as describeCondition, g as evaluateCondition, o as isTruthy, s as normalizeFlow, c as sanitizeOutputKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-ai-flows",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "description": "AI Flows — durable multi-step AI pipelines (deterministic + agentic) with human-in-the-loop, chaining, and cadence. Author flows in code (defineFlow) or as data (visual editor rows); one engine runs both on @voltro/workflow durability, @voltro/ai generation, storage artifacts, and notifications.",
   "keywords": [
     "voltro",
@@ -58,19 +58,19 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/ai": "0.75.0",
-    "@voltro/client": "0.75.0",
-    "@voltro/database": "0.75.0",
-    "@voltro/env": "0.75.0",
-    "@voltro/plugin-audit": "0.75.0",
-    "@voltro/plugin-multitenancy": "0.75.0",
-    "@voltro/plugin-soft-delete": "0.75.0",
-    "@voltro/protocol": "0.75.0",
-    "@voltro/runtime": "0.75.0",
-    "@voltro/workflow": "0.75.0"
+    "@voltro/ai": "0.76.0",
+    "@voltro/client": "0.76.0",
+    "@voltro/database": "0.76.0",
+    "@voltro/env": "0.76.0",
+    "@voltro/plugin-audit": "0.76.0",
+    "@voltro/plugin-multitenancy": "0.76.0",
+    "@voltro/plugin-soft-delete": "0.76.0",
+    "@voltro/protocol": "0.76.0",
+    "@voltro/runtime": "0.76.0",
+    "@voltro/workflow": "0.76.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.1"
+    "effect": "^3.22.2"
   },
   "publishConfig": {
     "access": "public"