@voltro/plugin-ai-flows 0.70.0 → 0.71.1

package/dist/{ir-BOv5uwYI.js → ir-B0rox9qW.js}

@@ -1,10 +1,11 @@
 import { Schema as e } from "effect";
+import { WorkflowRunHandleSchema as t } from "@voltro/protocol";
 //#region src/condition.ts
-var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = e.Struct({
+var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	ref: e.String,
-	op: t,
+	op: n,
 	value: e.optional(e.Unknown)
-}), r = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, i = (e, t) => {
+}), i = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, a = (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 {
@@ -13,21 +14,21 @@ var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = e.Struct({
 		return !1;
 	}
 	return String(e) === String(t);
-}, a = (e, t) => {
+}, o = (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 "truthy": return i(n);
+		case "falsy": return !i(n);
+		case "eq": return a(n, e.value);
+		case "neq": return !a(n, e.value);
 		case "contains": {
 			if (n == null) return !1;
-			if (Array.isArray(n)) return n.some((t) => i(t, e.value));
+			if (Array.isArray(n)) return n.some((t) => a(t, e.value));
 			let t = e.value;
 			return typeof t != "string" && typeof t != "number" ? !1 : String(n).includes(String(t));
 		}
 	}
-}, o = (e) => {
+}, s = (e) => {
 	switch (e.op) {
 		case "truthy": return `{{${e.ref}}} is set`;
 		case "falsy": return `{{${e.ref}}} is not set`;
@@ -35,53 +36,64 @@ var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = e.Struct({
 		case "neq": return `{{${e.ref}}} does not equal ${JSON.stringify(e.value)}`;
 		case "contains": return `{{${e.ref}}} contains ${JSON.stringify(e.value)}`;
 	}
-}, s = e.Literal("deterministic", "agentic"), c = e.Literal("draft", "active", "archived"), l = e.Literal("private", "organization", "shared"), u = e.Literal("pending", "running", "waiting", "succeeded", "failed", "cancelled"), d = e.Literal("manual", "cron"), f = e.Literal("agent", "generate", "structured", "note", "human"), p = e.Literal("text", "image", "video", "audio"), m = e.Literal("approve", "choice", "text"), h = e.Struct({
+}, c = 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({
 	value: e.String,
 	label: e.String
-}), g = e.Union(e.Struct({
+}), v = e.Union(e.Struct({
 	from: e.Literal("upload"),
 	url: e.String
 }), e.Struct({
 	from: e.Literal("step"),
-	ref: e.String
-})), _ = e.Record({
+	ref: e.String,
+	artifact: e.optional(e.Int.pipe(e.nonNegative()))
+})), y = e.Record({
 	key: e.String,
-	value: g
-}), v = e.Record({
+	value: v
+}), b = e.Record({
 	key: e.String,
 	value: e.Unknown
-}), y = e.Struct({
+}), x = 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({
 	id: e.String,
 	title: e.optional(e.String),
 	description: e.optional(e.String),
-	type: f,
+	type: m,
 	outputKey: e.optional(e.String),
 	prompt: e.optional(e.String),
-	modality: e.optional(p),
+	modality: e.optional(h),
 	model: e.optional(e.String),
-	params: e.optional(v),
-	mediaInputs: e.optional(_),
+	params: e.optional(b),
+	mediaInputs: e.optional(y),
 	agentRef: e.optional(e.String),
-	schema: e.optional(v),
-	reviewMode: e.optional(m),
-	options: e.optional(e.Array(h)),
-	when: e.optional(n),
+	schema: e.optional(b),
+	reviewMode: e.optional(g),
+	options: e.optional(e.Array(_)),
+	when: e.optional(r),
 	group: e.optional(e.String),
 	timeoutMs: e.optional(e.Number)
-}), b = e.Struct({
+}), w = 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)
-}), x = e.Struct({
+}), T = e.Struct({
 	flowRef: e.String,
 	mappings: e.Array(e.Struct({
 		targetKey: e.String,
 		sourceKey: e.String
 	})),
 	requireConfirmation: e.optional(e.Boolean)
-}), S = e.Struct({
+}), E = e.Struct({
 	frequency: e.optional(e.Literal("weekly", "monthly")),
 	repeats: e.Array(e.Number),
 	intervalWeeks: e.optional(e.Number),
@@ -89,39 +101,50 @@ var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = 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(v)
-}), C = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), w = e.Struct({
-	mode: m,
-	options: e.optional(e.Array(h)),
+	defaultInput: e.optional(b)
+}), D = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), O = e.Struct({
+	mode: g,
+	options: e.optional(e.Array(_)),
 	prompt: e.String
-}), T = e.Struct({
+}), k = e.Struct({
 	id: e.Number,
 	title: e.String,
 	description: e.optional(e.String),
-	type: f,
-	status: C,
+	type: m,
+	status: D,
 	startedAt: e.optional(e.String),
 	completedAt: e.optional(e.String),
 	costMicroUsd: e.optional(e.Number),
 	requestId: e.optional(e.String),
 	url: e.optional(e.String),
+	artifacts: e.optional(S),
 	output: e.optional(e.Struct({ text: e.String })),
 	errorMessage: e.optional(e.String),
 	skipReason: e.optional(e.String),
-	review: e.optional(w)
-}), E = e.Struct({
+	review: e.optional(O)
+}), A = e.Struct({
 	decision: e.optional(e.Literal("approve", "reject")),
 	value: e.optional(e.String),
 	text: e.optional(e.String),
 	respondedAt: e.optional(e.String)
-}), D = e.Struct({
+}), j = e.Struct({
+	runId: e.NonEmptyString,
+	stepIndex: e.Int.pipe(e.nonNegative()),
+	response: A
+}), M = e.Struct({
+	runId: e.NonEmptyString,
+	stepIndex: e.Int.pipe(e.nonNegative()),
+	executionId: e.NonEmptyString,
+	eventId: e.NonEmptyString,
+	status: e.Literal("accepted")
+}), N = e.Struct({
 	flowRef: e.String,
-	input: v,
+	input: b,
 	status: e.Literal("pending", "confirmed", "dismissed")
-}), O = 30, k = 1, A = 100, j = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), M = (e) => e.replace(/[^\w.-]/g, "_"), N = (e) => {
+}), P = 30, F = 1, I = 100, L = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), R = (e) => e.replace(/[^\w.-]/g, "_"), z = (e) => {
 	let t = (e.steps ?? []).map((e) => e.outputKey ? {
 		...e,
-		outputKey: M(e.outputKey)
+		outputKey: R(e.outputKey)
 	} : e), n = e.orchestratorModel || e.orchestratorInstructions ? {
 		...e.orchestratorModel ? { model: e.orchestratorModel } : {},
 		...e.orchestratorInstructions ? { instructions: e.orchestratorInstructions } : {}
@@ -130,7 +153,7 @@ var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = e.Struct({
 		name: e.name,
 		mode: e.mode ?? "deterministic",
 		steps: t,
-		maxSteps: j(e.maxSteps),
+		maxSteps: L(e.maxSteps),
 		brief: e.brief ?? [],
 		...n ? { orchestrator: n } : {},
 		...e.chain ? { chain: e.chain } : {},
@@ -139,4 +162,4 @@ var t = e.Literal("truthy", "falsy", "eq", "neq", "contains"), n = e.Struct({
 	};
 };
 //#endregion
-export { o as A, f as C, M as D, N as E, r as M, t as O, C as S, j as T, h as _, s as a, u as b, E as c, A as d, k as f, m as g, p as h, x as i, a as j, n as k, v as l, _ as m, D as n, c as o, g as p, S as r, y as s, b as t, O as u, w as v, l as w, T as x, d as y };
+export { L as A, O as C, D, k as E, s as F, o as I, i as L, R as M, n as N, m as O, r as P, _ as S, f as T, S as _, l as a, h as b, c, A as d, b as f, x as g, F as h, T as i, z as j, d as k, u as l, I as m, N as n, j as o, P as p, E as r, M as s, w as t, C as u, v, p as w, g as x, y };

package/dist/ir.d.ts

@@ -157,6 +157,51 @@ export declare const FlowMode: Schema.Literal<["deterministic", "agentic"]>;
 
 export declare type FlowMode = typeof FlowMode.Type;
 
+/** Bind the answer to the review actually displayed, not the latest waiting step. */
+export declare const FlowReviewInput: Schema.Struct<{
+    runId: typeof Schema.NonEmptyString;
+    stepIndex: Schema.filter<typeof Schema.Int>;
+    response: Schema.Struct<{
+        decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
+        value: Schema.optional<typeof Schema.String>;
+        text: Schema.optional<typeof Schema.String>;
+        respondedAt: Schema.optional<typeof Schema.String>;
+    }>;
+}>;
+
+export declare type FlowReviewInput = typeof FlowReviewInput.Type;
+
+/** Delivery accepted; consumption and the run's eventual outcome remain reactive state. */
+export declare const FlowReviewReceipt: Schema.Struct<{
+    runId: typeof Schema.NonEmptyString;
+    stepIndex: Schema.filter<typeof Schema.Int>;
+    executionId: typeof Schema.NonEmptyString;
+    eventId: typeof Schema.NonEmptyString;
+    status: Schema.Literal<["accepted"]>;
+}>;
+
+export declare type FlowReviewReceipt = typeof FlowReviewReceipt.Type;
+
+/** Submission evidence, separate from the flow run's execution status. */
+export declare const FlowStartReceipt: Schema.Struct<{
+    runId: typeof Schema.NonEmptyString;
+    requestId: typeof Schema.NonEmptyString;
+    admission: Schema.Struct<{
+        id: typeof Schema.String;
+        workflowName: typeof Schema.String;
+        executionId: Schema.NullOr<typeof Schema.String>;
+        status: Schema.Literal<["running", "succeeded", "queued", "dropped", "skipped", "replayed"]>;
+        deferral: Schema.optional<Schema.Struct<{
+            mode: typeof Schema.String;
+            dueAt: Schema.NullOr<typeof Schema.Number>;
+            retryAfterMs: Schema.NullOr<typeof Schema.Number>;
+            intentId: Schema.NullOr<typeof Schema.String>;
+        }>>;
+    }>;
+}>;
+
+export declare type FlowStartReceipt = typeof FlowStartReceipt.Type;
+
 /** Flow-definition lifecycle. */
 export declare const FlowStatus: Schema.Literal<["draft", "active", "archived"]>;
 
@@ -187,11 +232,11 @@ export declare const FlowStep: Schema.Struct<{
     }>, Schema.Struct<{
         from: Schema.Literal<["step"]>;
         ref: typeof Schema.String;
+        artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
     }>]>>>;
-    /** Allowed sub-agent id/name. The framework resolves a real id; any
-     *  legacy-numeric bridge stays in the consumer app's mapping. */
+    /** Allowed sub-agent id/name, resolved and authorized by the host. */
     agentRef: Schema.optional<typeof Schema.String>;
-    /** JSON Schema of the desired object (adapted to an Effect Schema at run). */
+    /** JSON Schema of the desired object, preserved and validated at run. */
     schema: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
     reviewMode: Schema.optional<Schema.Literal<["approve", "choice", "text"]>>;
     options: Schema.optional<Schema.Array$<Schema.Struct<{
@@ -266,7 +311,7 @@ export declare interface FlowStep {
     readonly timeoutMs?: number | undefined;
 }
 
-/** The HITL answer, written by `respond`. */
+/** The HITL answer; the engine projects it after consuming the durable signal. */
 export declare const HumanResponse: Schema.Struct<{
     decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
     value: Schema.optional<typeof Schema.String>;
@@ -309,18 +354,39 @@ export declare const MAX_STEPS_MAX = 100;
 
 export declare const MAX_STEPS_MIN = 1;
 
+/** One persisted media artifact. Storage identity is not a provider request ID.
+ *  Exactly one artifact per result has role `primary`; other roles are host-defined. */
+export declare const MediaArtifact: Schema.Struct<{
+    url: typeof Schema.NonEmptyString;
+    mediaType: typeof Schema.NonEmptyString;
+    role: typeof Schema.NonEmptyString;
+    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
+    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+}>;
+
+export declare type MediaArtifact = typeof MediaArtifact.Type;
+
+export declare const MediaArtifacts: Schema.filter<Schema.Array$<Schema.Struct<{
+    url: typeof Schema.NonEmptyString;
+    mediaType: typeof Schema.NonEmptyString;
+    role: typeof Schema.NonEmptyString;
+    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
+    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+}>>>;
+
 export declare const MediaInputs: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
     from: Schema.Literal<["upload"]>;
     url: typeof Schema.String;
 }>, Schema.Struct<{
     from: Schema.Literal<["step"]>;
     ref: typeof Schema.String;
+    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
 }>]>>;
 
 export declare type MediaInputs = typeof MediaInputs.Type;
 
-/** A media-input slot for a video `generate` step — either an uploaded URL or a
- *  reference to a prior step's output. Keyed by capability slot name
+/** A media-input slot — an absolute HTTP(S) uploaded URL or a reference to a
+ *  brief field/prior step's URL output. Keyed by capability slot name
  *  (`referenceImageUrl`, `lastFrameImageUrl`, `referenceVideoUrl`, …). */
 export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
     from: Schema.Literal<["upload"]>;
@@ -328,6 +394,7 @@ export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
 }>, Schema.Struct<{
     from: Schema.Literal<["step"]>;
     ref: typeof Schema.String;
+    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
 }>]>;
 
 export declare type MediaInputSlot = typeof MediaInputSlot.Type;
@@ -392,6 +459,14 @@ export declare const RunStep: Schema.Struct<{
     requestId: Schema.optional<typeof Schema.String>;
     /** Hosted media artifact URL (image/video/audio), via storage. */
     url: Schema.optional<typeof Schema.String>;
+    /** All media variants, including roles and storage references; url projects the primary artifact. */
+    artifacts: Schema.optional<Schema.filter<Schema.Array$<Schema.Struct<{
+        url: typeof Schema.NonEmptyString;
+        mediaType: typeof Schema.NonEmptyString;
+        role: typeof Schema.NonEmptyString;
+        storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
+        providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    }>>>>;
     /** Inline text output (rendered as markdown). */
     output: Schema.optional<Schema.Struct<{
         text: typeof Schema.String;
@@ -424,6 +499,7 @@ export declare interface RunStep {
     readonly costMicroUsd?: number | undefined;
     readonly requestId?: string | undefined;
     readonly url?: string | undefined;
+    readonly artifacts?: ReadonlyArray<MediaArtifact> | undefined;
     readonly output?: {
         readonly text: string;
     } | undefined;

package/dist/ir.js

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