@voltro/plugin-ai-flows 0.84.0 → 0.86.0

package/dist/workflow.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'effect';
-import { Workflow } from '@effect/workflow/Workflow';
+import { Workflow } from 'effect/workflow/Workflow';
 import { WorkflowMessagesCarrier } from '@voltro/workflow';
 
 /** The canonical name the launch action starts + the app re-export registers. */
@@ -22,15 +22,15 @@ export declare interface FlowRunPayload {
  */
 export declare const flowRunWorkflow: Workflow<"flow.run", Schema.Struct<{
     /** The pre-created `ai_flow_runs` row id the executor patches. */
-    runId: typeof Schema.String;
+    runId: Schema.String;
     /** Name (code flow) or id (data flow) to resolve the IR from. */
-    flowRef: typeof Schema.String;
+    flowRef: Schema.String;
     /** Brief values keyed by `BriefField.key`. */
-    input: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    input: Schema.$Record<Schema.String, Schema.Unknown>;
     /** manual | cron. */
-    source: Schema.Literal<["manual", "cron"]>;
+    source: Schema.Literals<readonly ["manual", "cron"]>;
     /** Correlation + idempotency key. */
-    requestId: typeof Schema.String;
+    requestId: Schema.String;
     /**
      * The chain of flows that led here, oldest first, INCLUDING this one.
      *
@@ -43,11 +43,13 @@ export declare const flowRunWorkflow: Workflow<"flow.run", Schema.Struct<{
      * Optional so a run started by an older caller (or by hand) still decodes;
      * an absent path is read as "this is the first flow", which it is.
      */
-    chainPath: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    chainPath: Schema.optional<Schema.$Array<Schema.String>>;
 }>, Schema.Struct<{
-    runId: typeof Schema.String;
-    status: Schema.Literal<["succeeded", "failed", "cancelled", "waiting"]>;
-}>, typeof Schema.Never> & WorkflowMessagesCarrier<{
+    readonly runId: Schema.String;
+    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled", "waiting"]>;
+}>, Schema.Never> & {
+    readonly name: "flow.run";
+} & WorkflowMessagesCarrier<{
     readonly signals: {};
     readonly updates: {};
 }>;

package/dist/workflow.js

@@ -6,17 +6,19 @@ var n = "flow.run", r = "flow-human-response", i = (e) => `${r}:${e}`, a = t({
 	payload: {
 		runId: e.String,
 		flowRef: e.String,
-		input: e.Record({
-			key: e.String,
-			value: e.Unknown
-		}),
-		source: e.Literal("manual", "cron"),
+		input: e.Record(e.String, e.Unknown),
+		source: e.Literals(["manual", "cron"]),
 		requestId: e.String,
 		chainPath: e.optional(e.Array(e.String))
 	},
 	success: e.Struct({
 		runId: e.String,
-		status: e.Literal("succeeded", "failed", "cancelled", "waiting")
+		status: e.Literals([
+			"succeeded",
+			"failed",
+			"cancelled",
+			"waiting"
+		])
 	}),
 	idempotencyKey: ({ requestId: e }) => `flow-run:${e}`,
 	internal: !0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-ai-flows",
-  "version": "0.84.0",
+  "version": "0.86.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.84.0",
-    "@voltro/client": "0.84.0",
-    "@voltro/database": "0.84.0",
-    "@voltro/env": "0.84.0",
-    "@voltro/plugin-audit": "0.84.0",
-    "@voltro/plugin-multitenancy": "0.84.0",
-    "@voltro/plugin-soft-delete": "0.84.0",
-    "@voltro/protocol": "0.84.0",
-    "@voltro/runtime": "0.84.0",
-    "@voltro/workflow": "0.84.0"
+    "@voltro/ai": "0.86.0",
+    "@voltro/client": "0.86.0",
+    "@voltro/database": "0.86.0",
+    "@voltro/env": "0.86.0",
+    "@voltro/plugin-audit": "0.86.0",
+    "@voltro/plugin-multitenancy": "0.86.0",
+    "@voltro/plugin-soft-delete": "0.86.0",
+    "@voltro/protocol": "0.86.0",
+    "@voltro/runtime": "0.86.0",
+    "@voltro/workflow": "0.86.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"

package/dist/ir-CdDUTf98.js

@@ -1,196 +0,0 @@
-import { Schema as e } from "effect";
-import { WorkflowControlResultSchema as t, WorkflowRunHandleSchema as n } from "@voltro/protocol";
-//#region src/condition.ts
-var r = e.Literal("truthy", "falsy", "eq", "neq", "contains"), i = e.Struct({
-	ref: e.String,
-	op: r,
-	value: e.optional(e.Unknown)
-}), 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 {
-		return JSON.stringify(e) === JSON.stringify(t);
-	} catch {
-		return !1;
-	}
-	return String(e) === String(t);
-}, s = (e, t) => {
-	let n = t[e.ref];
-	switch (e.op) {
-		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) => o(t, e.value));
-			let t = e.value;
-			return typeof t != "string" && typeof t != "number" ? !1 : String(n).includes(String(t));
-		}
-	}
-}, c = (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)}`;
-	}
-}, l = e.Struct({
-	runId: e.NonEmptyString,
-	requestId: e.NonEmptyString,
-	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", "cancelling", "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 e.status === "cancelled" && 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
-}), b = e.Union(e.Struct({
-	from: e.Literal("upload"),
-	url: e.String,
-	mediaType: e.optional(e.NonEmptyString)
-}), e.Struct({
-	from: e.Literal("step"),
-	ref: e.String,
-	artifact: e.optional(e.Int.pipe(e.nonNegative()))
-})), x = e.Record({
-	key: e.String,
-	value: b
-}), S = e.Record({
-	key: e.String,
-	value: e.Unknown
-}), C = e.Struct({
-	url: e.NonEmptyString,
-	mediaType: e.NonEmptyString,
-	role: e.NonEmptyString,
-	storageRefId: e.optional(e.NonEmptyString),
-	providerMetadata: e.optional(e.Unknown)
-}), 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: g,
-	outputKey: e.optional(e.String),
-	prompt: e.optional(e.String),
-	modality: e.optional(_),
-	model: e.optional(e.String),
-	params: e.optional(S),
-	mediaInputs: e.optional(x),
-	agentRef: e.optional(e.String),
-	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)
-}), 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)
-}), D = e.Struct({
-	flowRef: e.String,
-	mappings: e.Array(e.Struct({
-		targetKey: e.String,
-		sourceKey: e.String
-	})),
-	requireConfirmation: e.optional(e.Boolean)
-}), O = e.Struct({
-	frequency: e.optional(e.Literal("weekly", "monthly")),
-	repeats: e.Array(e.Number),
-	intervalWeeks: e.optional(e.Number),
-	anchorDate: e.optional(e.String),
-	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(S)
-}), k = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), A = e.Struct({
-	mode: v,
-	options: e.optional(e.Array(y)),
-	prompt: e.String
-}), 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()))
-}), P = e.Struct({
-	costMicroUsd: e.optional(e.Finite.pipe(e.nonNegative())),
-	costSource: e.optional(j),
-	requestId: e.optional(e.NonEmptyString),
-	usage: e.optional(N)
-}), F = e.Struct({
-	id: e.Number,
-	title: e.String,
-	description: e.optional(e.String),
-	type: g,
-	status: k,
-	agentRef: e.optional(e.String),
-	modality: e.optional(_),
-	startedAt: e.optional(e.String),
-	completedAt: e.optional(e.String),
-	costMicroUsd: e.optional(e.Number),
-	costSource: e.optional(j),
-	requestId: e.optional(e.String),
-	usage: e.optional(N),
-	url: e.optional(e.String),
-	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(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)
-}), L = e.Struct({
-	runId: e.NonEmptyString,
-	stepIndex: e.Int.pipe(e.nonNegative()),
-	response: I
-}), R = e.Struct({
-	runId: e.NonEmptyString,
-	stepIndex: e.Int.pipe(e.nonNegative()),
-	executionId: e.NonEmptyString,
-	eventId: e.NonEmptyString,
-	status: e.Literal("accepted")
-}), z = e.Struct({
-	flowRef: e.String,
-	input: S,
-	status: e.Literal("pending", "confirmed", "dismissed")
-}), 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: W(e.outputKey)
-	} : e), n = e.orchestratorModel || e.orchestratorInstructions ? {
-		...e.orchestratorModel ? { model: e.orchestratorModel } : {},
-		...e.orchestratorInstructions ? { instructions: e.orchestratorInstructions } : {}
-	} : void 0;
-	return {
-		name: e.name,
-		mode: e.mode ?? "deterministic",
-		steps: t,
-		maxSteps: U(e.maxSteps),
-		brief: e.brief ?? [],
-		...n ? { orchestrator: n } : {},
-		...e.chain ? { chain: e.chain } : {},
-		...e.cadence ? { cadence: e.cadence } : {},
-		...e.humanTimeoutMs != null && Number.isFinite(e.humanTimeoutMs) ? { humanTimeoutMs: e.humanTimeoutMs } : {}
-	};
-};
-//#endregion
-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 };