@voltro/plugin-ai-flows 0.1.0

package/dist/index.js

@@ -0,0 +1,965 @@
+import { BriefField as e, ChainPending as t, FlowCadence as n, FlowChain as r, FlowMode as i, FlowStatus as a, FlowStep as o, HumanResponse as s, Json as c, MAX_STEPS_DEFAULT as l, MAX_STEPS_MAX as u, MAX_STEPS_MIN as d, MediaInputSlot as f, MediaInputs as p, Modality as m, ReviewMode as h, ReviewOption as ee, RunReview as te, RunSource as ne, RunStatus as re, RunStep as ie, RunStepStatus as ae, StepType as oe, Visibility as se, clampMaxSteps as ce, normalizeFlow as g, sanitizeOutputKey as le } from "./ir.js";
+import { FLOW_RUN_WORKFLOW as _, HUMAN_RESPONSE_SIGNAL as v } from "./workflow.js";
+import { FlowBriefIncomplete as ue, FlowCapabilityMissing as y, FlowDependencyError as de, FlowNotAwaitingResponse as fe, FlowNotFound as pe, FlowRunNotFound as b, FlowValidationError as me } from "./errors.js";
+import { n as he, t as ge } from "./cadence-Bt6dPelT.js";
+import { Effect as x, Schema as S } from "effect";
+import { definePlugin as _e } from "@voltro/protocol";
+import { boolean as ve, eq as C, id as ye, integer as w, json as T, queryFor as E, table as D, text as O, timestamp as k } from "@voltro/database";
+import { tenant as A } from "@voltro/plugin-multitenancy/mixin";
+import { audit as j } from "@voltro/plugin-audit/mixin";
+import { softDelete as be } from "@voltro/plugin-soft-delete/mixin";
+import { awaitSignalSuspending as xe, step as M } from "@voltro/workflow";
+import { defineTool as N, estimateCostUsd as P, gatewayCostUsd as F, generateImage as Se, generateObject as I, generateObjectWithTools as Ce, generateSpeech as we, generateText as L, generateVideo as Te } from "@voltro/ai";
+//#region src/table.ts
+var R = D("ai_flows", {
+	id: ye({ prefix: "aifl" }),
+	name: O(),
+	description: O().nullable(),
+	mode: O().default("deterministic"),
+	status: O().default("draft"),
+	visibility: O().default("private"),
+	orchestratorModel: O().nullable(),
+	orchestratorInstructions: O().nullable(),
+	maxSteps: w().default(30),
+	steps: T().nullable(),
+	inputSchema: T().nullable(),
+	chainTo: T().nullable(),
+	cadence: T().nullable(),
+	isEnabled: ve().default(!0),
+	metadata: T().nullable(),
+	icon: O().nullable(),
+	color: O().nullable(),
+	avatarUrl: O().nullable(),
+	usageCount: w().default(0),
+	ownerId: O().nullable()
+}).with(A(), j(), be()).index(["status"]).index(["visibility"]).reactive(), z = D("ai_flow_runs", {
+	id: ye({ prefix: "aifr" }),
+	flowRef: O(),
+	flowName: O().nullable(),
+	mode: O().default("deterministic"),
+	status: O().default("pending"),
+	source: O().nullable(),
+	requestId: O(),
+	input: T().nullable(),
+	output: T().nullable(),
+	steps: T().nullable(),
+	currentStep: w().default(0),
+	totalSteps: w().default(0),
+	humanResponse: T().nullable(),
+	chainPending: T().nullable(),
+	costMicroUsd: w().default(0),
+	durationMs: w().nullable(),
+	error: O().nullable(),
+	errorMessage: O().nullable(),
+	startedAt: k().nullable(),
+	completedAt: k().nullable(),
+	cancelledAt: k().nullable(),
+	sessionId: O().nullable(),
+	sessionName: O().nullable(),
+	ownerId: O().nullable(),
+	metadata: T().nullable()
+}).with(A(), j()).index(["flowRef"]).index(["status"]).index(["requestId"]).reactive(), B = [R, z], Ee = /\{\{\s*([\w.-]+)\s*\}\}/g, V = (e) => {
+	let t = [];
+	for (let n of e.matchAll(Ee)) t.push(n[1]);
+	return t;
+}, H = (e, t) => e.replace(Ee, (e, n) => {
+	let r = t[n];
+	return r == null ? "" : typeof r == "string" ? r : JSON.stringify(r);
+}), De = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of V(e)) t[r] == null && !n.has(r) && n.add(r);
+	return [...n];
+}, U = /* @__PURE__ */ new Map(), Oe = (e) => {
+	U.set(e.name, e);
+}, ke = (e) => U.get(e), Ae = () => [...U.values()], je = () => U.clear(), Me = S.Struct({
+	value: S.optional(S.Unknown),
+	text: S.optional(S.String),
+	url: S.optional(S.String),
+	costMicroUsd: S.optional(S.Number),
+	requestId: S.optional(S.String),
+	error: S.optional(S.String)
+}), W = () => (/* @__PURE__ */ new Date()).toISOString(), Ne = (e) => Math.round(e * 1e6), G = (e, t) => e.resolveModel?.(t) ?? G(e, t), K = (e, t, n) => {
+	let r = F(t);
+	return typeof r == "number" ? Ne(r) : P(e, { model: n ?? "unknown" }).costMicroUsd ?? 0;
+}, q = (e, t, n) => x.promise(() => e.store.update(z.tableName, t, n).then(() => void 0)).pipe(x.catchAllCause(() => x.void)), Pe = (e, t) => x.promise(async () => (await e.store.query(E(z).where(C("id", t)).descriptor))[0]?.status === "cancelled").pipe(x.catchAllCause(() => x.succeed(!1))), J = (e, t) => x.gen(function* () {
+	let n = ke(t);
+	if (n) return n;
+	let r = (yield* x.promise(() => e.store.query(E(R).where(C("id", t)).descriptor)))[0];
+	return r ? g({
+		name: r.name ?? t,
+		mode: r.mode,
+		steps: r.steps ?? [],
+		maxSteps: r.maxSteps ?? null,
+		brief: r.inputSchema ?? [],
+		orchestratorModel: r.orchestratorModel ?? null,
+		orchestratorInstructions: r.orchestratorInstructions ?? null,
+		chain: r.chainTo ?? null,
+		cadence: r.cadence ?? null
+	}) : yield* x.fail(new pe({
+		flowRef: t,
+		message: `no flow registered or stored for "${t}"`
+	}));
+}), Fe = (e, t, n, r) => x.gen(function* () {
+	let e = H(n.prompt ?? "", r), i = De(n.prompt ?? "", r);
+	if (i.length > 0) return { error: new de({
+		stepId: n.id,
+		unresolvedRef: i[0],
+		message: `step "${n.id}" references unresolved {{${i[0]}}}`
+	}).message };
+	switch (n.type) {
+		case "note": return {
+			value: e,
+			text: e,
+			costMicroUsd: 0
+		};
+		case "agent": {
+			if (!n.agentRef) return { error: "agent step missing agentRef" };
+			if (!t.resolveAgent) return { error: new y({
+				capability: "resolveAgent",
+				message: "no agent resolver configured"
+			}).message };
+			let r = yield* t.resolveAgent(n.agentRef).pipe(x.map((e) => ({
+				ok: !0,
+				a: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			if (!r.ok) return { error: r.e.message };
+			let i = yield* L({
+				system: r.a.system,
+				prompt: e,
+				provider: G(t, r.a.model)
+			}).pipe(x.map((e) => ({
+				ok: !0,
+				r: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			return i.ok ? {
+				value: i.r.text,
+				text: i.r.text,
+				costMicroUsd: K(i.r.usage, i.r.providerMetadata, r.a.model)
+			} : { error: String(i.e.message ?? i.e) };
+		}
+		case "structured": {
+			let r = n.model ?? t.defaultModels?.text, i = yield* I({
+				prompt: e,
+				schema: S.Record({
+					key: S.String,
+					value: S.Unknown
+				}),
+				...r ? { provider: G(t, r) } : {}
+			}).pipe(x.map((e) => ({
+				ok: !0,
+				r: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			return i.ok ? {
+				value: i.r.object,
+				text: JSON.stringify(i.r.object, null, 2),
+				costMicroUsd: K(i.r.usage, i.r.providerMetadata, r)
+			} : { error: String(i.e.message ?? i.e) };
+		}
+		case "generate": {
+			let r = n.modality ?? "text";
+			if (r === "text") {
+				let r = n.model ?? t.defaultModels?.text, i = yield* L({
+					prompt: e,
+					...r ? { provider: G(t, r) } : {}
+				}).pipe(x.map((e) => ({
+					ok: !0,
+					r: e
+				})), x.catchAll((e) => x.succeed({
+					ok: !1,
+					e
+				})));
+				return i.ok ? {
+					value: i.r.text,
+					text: i.r.text,
+					costMicroUsd: K(i.r.usage, i.r.providerMetadata, r)
+				} : { error: String(i.e.message ?? i.e) };
+			}
+			if (!t.generateMedia) return { error: new y({
+				capability: `media:${r}`,
+				message: `no media generator configured for ${r}`
+			}).message };
+			let i = n.model ?? t.defaultModels?.[r], a = yield* t.generateMedia({
+				modality: r,
+				...i ? { model: i } : {},
+				prompt: e,
+				...n.params ? { params: n.params } : {}
+			}).pipe(x.map((e) => ({
+				ok: !0,
+				m: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			return a.ok ? {
+				value: a.m.url,
+				url: a.m.url,
+				...a.m.requestId ? { requestId: a.m.requestId } : {},
+				costMicroUsd: a.m.costMicroUsd ?? 0
+			} : { error: a.e.message };
+		}
+		case "human": return { error: new y({
+			capability: "human",
+			message: "human-in-the-loop steps are not yet wired (task #35)"
+		}).message };
+		default: return { error: `unknown step type: ${String(n.type)}` };
+	}
+}), Ie = (e, t, n, r, i, a) => x.gen(function* () {
+	let o = { ...i }, c = r.steps.map((e, t) => ({
+		id: t,
+		title: e.title ?? `Step ${t + 1}`,
+		type: e.type,
+		status: "pending",
+		...e.description ? { description: e.description } : {}
+	})), l = 0;
+	yield* q(e, n, {
+		status: "running",
+		steps: c,
+		totalSteps: r.steps.length,
+		currentStep: 0,
+		startedAt: W()
+	});
+	for (let [i, u] of r.steps.entries()) {
+		if (yield* Pe(e, n)) return {
+			runId: n,
+			status: "cancelled"
+		};
+		if (u.type === "human") {
+			let d = {
+				mode: u.reviewMode ?? "approve",
+				...u.options ? { options: u.options } : {},
+				prompt: H(u.prompt ?? "", o)
+			};
+			c[i] = {
+				...c[i],
+				status: "waiting",
+				startedAt: W(),
+				review: d
+			}, yield* q(e, n, {
+				steps: c,
+				status: "waiting",
+				currentStep: i
+			}), t.onEvent && (yield* t.onEvent({
+				kind: "review-needed",
+				runId: n,
+				flowName: r.name,
+				ownerId: a.ownerId,
+				source: a.source
+			}).pipe(x.catchAllCause(() => x.void)));
+			let f = yield* xe(e, {
+				name: v,
+				schema: s
+			}).pipe(x.map((e) => ({
+				ok: !0,
+				a: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			if (!f.ok) return c[i] = {
+				...c[i],
+				status: "failed",
+				completedAt: W(),
+				errorMessage: "human review timed out or failed to decode"
+			}, yield* q(e, n, {
+				steps: c,
+				status: "failed",
+				errorMessage: "human review timed out",
+				completedAt: W(),
+				costMicroUsd: l
+			}), {
+				runId: n,
+				status: "failed"
+			};
+			let p = f.a;
+			if (p.decision === "reject") return c[i] = {
+				...c[i],
+				status: "failed",
+				completedAt: W(),
+				errorMessage: "rejected by reviewer"
+			}, yield* q(e, n, {
+				steps: c,
+				status: "cancelled",
+				completedAt: W(),
+				costMicroUsd: l
+			}), {
+				runId: n,
+				status: "cancelled"
+			};
+			u.outputKey && (o[u.outputKey] = p.value ?? p.text ?? p.decision ?? !0), c[i] = {
+				...c[i],
+				status: "succeeded",
+				completedAt: W(),
+				output: { text: String(p.text ?? p.value ?? p.decision ?? "approved") }
+			}, yield* q(e, n, {
+				steps: c,
+				status: "running",
+				currentStep: i + 1
+			});
+			continue;
+		}
+		c[i] = {
+			...c[i],
+			status: "running",
+			startedAt: W()
+		}, yield* q(e, n, {
+			steps: c,
+			currentStep: i
+		});
+		let d = yield* M({
+			name: `flow-${i}-${u.id}`,
+			input: { index: i },
+			success: Me,
+			execute: Fe(e, t, u, o)
+		});
+		if (d.error) return c[i] = {
+			...c[i],
+			status: "failed",
+			completedAt: W(),
+			errorMessage: d.error
+		}, yield* q(e, n, {
+			steps: c,
+			status: "failed",
+			errorMessage: d.error,
+			completedAt: W(),
+			costMicroUsd: l
+		}), {
+			runId: n,
+			status: "failed"
+		};
+		u.outputKey && d.value !== void 0 && (o[u.outputKey] = d.value), l += d.costMicroUsd ?? 0, c[i] = {
+			...c[i],
+			status: "succeeded",
+			completedAt: W(),
+			...d.text ? { output: { text: d.text } } : {},
+			...d.url ? { url: d.url } : {},
+			...d.requestId ? { requestId: d.requestId } : {},
+			...d.costMicroUsd ? { costMicroUsd: d.costMicroUsd } : {}
+		}, yield* q(e, n, {
+			steps: c,
+			currentStep: i + 1,
+			costMicroUsd: l
+		});
+	}
+	let u = {};
+	for (let e of r.steps) e.outputKey && o[e.outputKey] !== void 0 && (u[e.outputKey] = o[e.outputKey]);
+	return yield* q(e, n, {
+		status: "succeeded",
+		output: u,
+		completedAt: W(),
+		costMicroUsd: l
+	}), {
+		runId: n,
+		status: "succeeded",
+		output: u
+	};
+}), Le = (e, t, n, r, i, a) => x.gen(function* () {
+	let o = n.chain;
+	if (!o || o.flowRef === n.name || o.flowRef === a.flowRef) return;
+	let s = {
+		...r,
+		...i
+	}, c = {};
+	for (let e of o.mappings) e.sourceKey in s && (c[e.targetKey] = s[e.sourceKey]);
+	if (o.requireConfirmation) {
+		yield* q(e, t, { chainPending: {
+			flowRef: o.flowRef,
+			input: c,
+			status: "pending"
+		} });
+		return;
+	}
+	let l = e.workflows;
+	if (!l) return;
+	let u = `${t}--chain`, d = `${a.requestId}--chain`;
+	yield* x.promise(async () => {
+		try {
+			await e.store.insert(z.tableName, {
+				id: u,
+				flowRef: o.flowRef,
+				flowName: o.flowRef,
+				status: "pending",
+				source: a.source,
+				requestId: d,
+				input: c
+			});
+		} catch {}
+		await l.child("flow.run", {
+			runId: u,
+			flowRef: o.flowRef,
+			input: c,
+			source: a.source,
+			requestId: d
+		});
+	}).pipe(x.catchAllCause(() => x.void));
+}), Re = (e) => e.steps.length === 0 ? "" : "Suggested plan (you MAY reorder, insert, or skip steps):\n" + e.steps.map((e, t) => `${t + 1}. [${e.type}${e.modality ? `/${e.modality}` : ""}] ${e.title ?? e.id}${e.prompt ? `: ${e.prompt}` : ""}`).join("\n"), ze = (e) => {
+	let t = Object.entries(e);
+	return t.length === 0 ? "Execute the flow." : "Brief for this run:\n" + t.map(([e, t]) => `- ${e}: ${typeof t == "string" ? t : JSON.stringify(t)}`).join("\n");
+}, Be = (e) => [
+	e.orchestrator?.instructions ?? "You are an orchestrator that uses the available tools to produce a bundled result.",
+	Re(e),
+	"When finished, emit a JSON object mapping each deliverable name (outputKey) to its value."
+].filter(Boolean).join("\n\n"), Ve = S.Struct({
+	object: S.Record({
+		key: S.String,
+		value: S.Unknown
+	}),
+	planCostMicroUsd: S.Number,
+	toolCostMicroUsd: S.Number,
+	steps: S.Array(ie),
+	error: S.optional(S.String)
+}), He = (e, t, n, r, i, a) => x.gen(function* () {
+	yield* q(e, n, {
+		status: "running",
+		startedAt: W(),
+		totalSteps: r.steps.length
+	});
+	let o = yield* M({
+		name: "flow-agentic",
+		input: { flowRef: r.name },
+		success: Ve,
+		execute: x.gen(function* () {
+			let o = [], s = 0, c = (e) => {
+				let t = o.length;
+				return o.push({
+					id: t,
+					status: "running",
+					startedAt: W(),
+					...e
+				}), t;
+			}, l = (e, t) => {
+				o[e] = {
+					...o[e],
+					completedAt: W(),
+					...t
+				};
+			}, u = () => q(e, n, {
+				steps: o,
+				currentStep: o.length,
+				costMicroUsd: s
+			}), d = N({
+				name: "run_agent",
+				description: "Delegate a text task to an allowed sub-agent. Returns the agent's text.",
+				input: S.Struct({
+					agentRef: S.String,
+					prompt: S.String
+				}),
+				execute: ({ agentRef: e, prompt: n }) => x.gen(function* () {
+					let r = c({
+						title: `agent:${e}`,
+						type: "agent"
+					});
+					if (yield* u(), !t.resolveAgent) return l(r, {
+						status: "failed",
+						errorMessage: "no agent resolver configured"
+					}), yield* u(), "ERROR: no agent resolver configured";
+					let i = yield* t.resolveAgent(e).pipe(x.map((e) => ({
+						ok: !0,
+						a: e
+					})), x.catchAll((e) => x.succeed({
+						ok: !1,
+						e
+					})));
+					if (!i.ok) return l(r, {
+						status: "failed",
+						errorMessage: i.e.message
+					}), yield* u(), `ERROR: ${i.e.message}`;
+					let a = yield* L({
+						system: i.a.system,
+						prompt: n,
+						provider: G(t, i.a.model)
+					}).pipe(x.map((e) => ({
+						ok: !0,
+						r: e
+					})), x.catchAll((e) => x.succeed({
+						ok: !1,
+						e
+					})));
+					if (!a.ok) {
+						let e = String(a.e.message ?? a.e);
+						return l(r, {
+							status: "failed",
+							errorMessage: e
+						}), yield* u(), `ERROR: ${e}`;
+					}
+					let o = K(a.r.usage, a.r.providerMetadata, i.a.model);
+					return s += o, l(r, {
+						status: "succeeded",
+						output: { text: a.r.text },
+						costMicroUsd: o
+					}), yield* u(), a.r.text;
+				})
+			}), f = N({
+				name: "generate_media",
+				description: "Generate an image, video, or audio artifact. Returns the hosted URL.",
+				input: S.Struct({
+					modality: S.Literal("image", "video", "audio"),
+					prompt: S.String,
+					model: S.optional(S.String)
+				}),
+				execute: ({ modality: e, prompt: n, model: r }) => x.gen(function* () {
+					let i = c({
+						title: `media:${e}`,
+						type: "generate"
+					});
+					if (yield* u(), !t.generateMedia) return l(i, {
+						status: "failed",
+						errorMessage: `no media generator for ${e}`
+					}), yield* u(), `ERROR: no media generator configured for ${e}`;
+					let a = yield* t.generateMedia({
+						modality: e,
+						prompt: n,
+						...r ? { model: r } : {}
+					}).pipe(x.map((e) => ({
+						ok: !0,
+						r: e
+					})), x.catchAll((e) => x.succeed({
+						ok: !1,
+						e
+					})));
+					return a.ok ? (s += a.r.costMicroUsd ?? 0, l(i, {
+						status: "succeeded",
+						url: a.r.url,
+						...a.r.requestId ? { requestId: a.r.requestId } : {},
+						costMicroUsd: a.r.costMicroUsd ?? 0
+					}), yield* u(), a.r.url) : (l(i, {
+						status: "failed",
+						errorMessage: a.e.message
+					}), yield* u(), `ERROR: ${a.e.message}`);
+				})
+			}), p = N({
+				name: "pick_structured",
+				description: "Produce a JSON object for a task. Returns the object.",
+				input: S.Struct({
+					prompt: S.String,
+					model: S.optional(S.String)
+				}),
+				execute: ({ prompt: e, model: n }) => x.gen(function* () {
+					let r = c({
+						title: "structured",
+						type: "structured"
+					});
+					yield* u();
+					let i = yield* I({
+						prompt: e,
+						schema: S.Record({
+							key: S.String,
+							value: S.Unknown
+						}),
+						...n ? { provider: G(t, n) } : {}
+					}).pipe(x.map((e) => ({
+						ok: !0,
+						r: e
+					})), x.catchAll((e) => x.succeed({
+						ok: !1,
+						e
+					})));
+					if (!i.ok) {
+						let e = String(i.e.message ?? i.e);
+						return l(r, {
+							status: "failed",
+							errorMessage: e
+						}), yield* u(), { error: e };
+					}
+					let a = K(i.r.usage, i.r.providerMetadata, n);
+					return s += a, l(r, {
+						status: "succeeded",
+						output: { text: JSON.stringify(i.r.object) },
+						costMicroUsd: a
+					}), yield* u(), i.r.object;
+				})
+			}), m = t.memoryPrefix ? yield* t.memoryPrefix(a).pipe(x.catchAll(() => x.succeed(""))) : "", h = yield* Ce({
+				system: m ? `${m}\n\n${Be(r)}` : Be(r),
+				prompt: ze(i),
+				schema: S.Record({
+					key: S.String,
+					value: S.Unknown
+				}),
+				tools: {
+					run_agent: d,
+					generate_media: f,
+					pick_structured: p
+				},
+				maxSteps: r.maxSteps,
+				...r.orchestrator?.model ? { provider: G(t, r.orchestrator.model) } : {}
+			}).pipe(x.map((e) => ({
+				ok: !0,
+				r: e
+			})), x.catchAll((e) => x.succeed({
+				ok: !1,
+				e
+			})));
+			return h.ok ? {
+				object: h.r.object,
+				planCostMicroUsd: K(h.r.usage, h.r.providerMetadata, r.orchestrator?.model),
+				toolCostMicroUsd: s,
+				steps: o
+			} : {
+				object: {},
+				planCostMicroUsd: 0,
+				toolCostMicroUsd: s,
+				steps: o,
+				error: String(h.e.message ?? h.e)
+			};
+		})
+	}), s = o.planCostMicroUsd + o.toolCostMicroUsd;
+	return o.error ? (yield* q(e, n, {
+		status: "failed",
+		steps: o.steps,
+		errorMessage: o.error,
+		completedAt: W(),
+		costMicroUsd: s
+	}), {
+		runId: n,
+		status: "failed"
+	}) : (yield* q(e, n, {
+		status: "succeeded",
+		steps: o.steps,
+		output: o.object,
+		completedAt: W(),
+		costMicroUsd: s
+	}), {
+		runId: n,
+		status: "succeeded",
+		output: o.object
+	});
+}), Ue = (e, t = {}) => (n, r) => x.gen(function* () {
+	let { runId: r, flowRef: i, input: a } = n, o = yield* M({
+		name: "flow-0-resolve",
+		input: { flowRef: i },
+		success: S.Struct({
+			ir: S.Unknown,
+			error: S.optional(S.String)
+		}),
+		execute: J(e, i).pipe(x.map((e) => ({ ir: e })), x.catchAll((e) => x.succeed({
+			ir: void 0,
+			error: e.message
+		})))
+	});
+	if (o.error || !o.ir) return yield* q(e, r, {
+		status: "failed",
+		errorMessage: o.error ?? "flow not found",
+		completedAt: W()
+	}), {
+		runId: r,
+		status: "failed"
+	};
+	let s = o.ir, c = (yield* x.promise(() => e.store.query(E(z).where(C("id", r)).descriptor)).pipe(x.catchAllCause(() => x.succeed([]))))[0]?.ownerId ?? null, l = s.mode === "agentic" ? yield* He(e, t, r, s, a, c) : yield* Ie(e, t, r, s, a, {
+		ownerId: c,
+		source: n.source
+	});
+	return l.status === "succeeded" && s.chain && (yield* Le(e, r, s, a, l.output ?? {}, n)), t.onEvent && (l.status === "succeeded" || l.status === "failed") && (yield* t.onEvent({
+		kind: l.status,
+		runId: r,
+		flowName: s.name,
+		ownerId: c,
+		source: n.source
+	}).pipe(x.catchAllCause(() => x.void))), l;
+}), We = {
+	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
+	})
+}, Ge = (e) => e.map((e, t) => "id" in e && e.id ? e : {
+	id: `step-${t}`,
+	...e
+}), Ke = (e) => {
+	let t = new Set(e.brief.map((e) => e.key)), n = [];
+	for (let r of e.steps) {
+		for (let e of V(r.prompt ?? "")) t.has(e) || n.push(`step "${r.id}" references {{${e}}} which is not a brief field or a prior step outputKey`);
+		r.outputKey && t.add(le(r.outputKey));
+	}
+	if (n.length > 0) throw new me({
+		flowRef: e.name,
+		message: `flow "${e.name}" has ${n.length} unresolved reference(s)`,
+		issues: n
+	});
+}, qe = (e) => {
+	let t = g({
+		name: e.name,
+		mode: e.mode,
+		steps: Ge(e.steps),
+		maxSteps: e.maxSteps,
+		brief: e.brief,
+		orchestratorModel: e.orchestrator?.model,
+		orchestratorInstructions: e.orchestrator?.instructions,
+		chain: e.chain,
+		cadence: e.cadence
+	});
+	return Ke(t), Oe(t), t;
+}, Y = (e) => String(e).padStart(2, "0"), X = (e, t) => `cron-${e}-${t.getFullYear()}${Y(t.getMonth() + 1)}${Y(t.getDate())}-${Y(t.getHours())}${Y(t.getMinutes())}`, Je = async (e) => {
+	let t = [];
+	for (let e of Ae()) e.cadence && (e.cadence.repeats?.length ?? 0) > 0 && t.push({
+		flowRef: e.name,
+		cadence: e.cadence,
+		defaultInput: e.cadence.defaultInput ?? {}
+	});
+	let n = await e.store.select("ai_flows").where("isEnabled", !0).all();
+	for (let e of n) e.id && e.cadence && (e.cadence.repeats?.length ?? 0) > 0 && t.push({
+		flowRef: e.id,
+		cadence: e.cadence,
+		defaultInput: e.cadence.defaultInput ?? {}
+	});
+	return t;
+}, Ye = async (e, t = /* @__PURE__ */ new Date()) => {
+	let n = e.workflows, r = [], i = 0, a = await Je(e).catch(() => []);
+	for (let o of a) {
+		if (!ge(o.cadence, t) || (i += 1, !n)) continue;
+		let a = X(o.flowRef, t), s = `run-${a}`;
+		try {
+			try {
+				await e.store.insert("ai_flow_runs", {
+					id: s,
+					flowRef: o.flowRef,
+					flowName: o.flowRef,
+					status: "pending",
+					source: "cron",
+					requestId: a,
+					input: o.defaultInput
+				});
+			} catch {}
+			await n.start("flow.run", {
+				runId: s,
+				flowRef: o.flowRef,
+				input: o.defaultInput,
+				source: "cron",
+				requestId: a
+			}), r.push(a);
+		} catch {}
+	}
+	return {
+		matched: i,
+		started: r
+	};
+}, Xe = (e) => ({
+	name: "gateway",
+	model: e
+}), Ze = (e) => Math.round(e * 1e6), Z = (e, t, n) => {
+	let r = F(t);
+	return typeof r == "number" ? Ze(r) : e ? P(e, { model: n ?? "unknown" }).costMicroUsd ?? 0 : 0;
+}, Qe = (e, t) => (n) => {
+	let r = n.model, i = (e) => t?.resolveModel?.(e) ?? Xe(e);
+	return x.gen(function* () {
+		if (n.modality === "image") {
+			let t = yield* Se({
+				prompt: n.prompt,
+				...r ? { provider: i(r) } : {}
+			}), a = t.images[0];
+			if (!a) return yield* x.fail(new y({
+				capability: "media:image",
+				message: "no image produced"
+			}));
+			let o = yield* x.promise(() => e.put({
+				data: a.data,
+				mediaType: a.mediaType
+			}));
+			return {
+				url: o.url,
+				...o.refId ? { requestId: o.refId } : {},
+				costMicroUsd: Z(t.usage, t.providerMetadata, r)
+			};
+		}
+		if (n.modality === "audio") {
+			let t = yield* we({
+				text: n.prompt,
+				...r ? { provider: i(r) } : {}
+			}), a = yield* x.promise(() => e.put({
+				data: t.audio.data,
+				mediaType: t.audio.mediaType
+			}));
+			return {
+				url: a.url,
+				...a.refId ? { requestId: a.refId } : {},
+				costMicroUsd: Z(t.usage, t.providerMetadata, r)
+			};
+		}
+		let t = yield* Te({
+			prompt: n.prompt,
+			...r ? { provider: i(r) } : {},
+			...n.params ? { params: n.params } : {}
+		}), a;
+		if (t.video.url) a = e.ingestUrl ? yield* x.promise(() => e.ingestUrl(t.video.url)) : { url: t.video.url };
+		else if (t.video.data) a = yield* x.promise(() => e.put({
+			data: t.video.data,
+			mediaType: t.video.mediaType
+		}));
+		else return yield* x.fail(new y({
+			capability: "media:video",
+			message: "no video produced"
+		}));
+		return {
+			url: a.url,
+			...a.refId ? { requestId: a.refId } : {},
+			costMicroUsd: Z(t.usage, t.providerMetadata, r)
+		};
+	}).pipe(x.catchAll((e) => e instanceof y ? x.fail(e) : x.fail(new y({
+		capability: `media:${n.modality}`,
+		message: String(e.message ?? e)
+	}))));
+}, Q = () => globalThis.crypto?.randomUUID?.() ?? `req-${Date.now().toString(36)}`, $e = (e) => e.request?.subject?.id ?? null, $ = (e, t) => x.promise(() => e.store.query(E(z).where(C("id", t)).descriptor)).pipe(x.map((e) => e[0])), et = (e, t) => x.gen(function* () {
+	let n = yield* J(e, t.flowRef), r = t.input ?? {}, i = n.brief.filter((e) => e.required && e.type !== "boolean" && (r[e.key] === void 0 || r[e.key] === null || r[e.key] === "")).map((e) => e.key);
+	if (i.length > 0) return yield* x.fail(new ue({
+		missing: i,
+		message: `missing required brief field(s): ${i.join(", ")}`
+	}));
+	let a = Q(), o = `run-${a}`, s = t.source ?? "manual";
+	yield* x.promise(() => e.store.insert(z.tableName, {
+		id: o,
+		flowRef: t.flowRef,
+		flowName: n.name,
+		mode: n.mode,
+		status: "pending",
+		source: s,
+		requestId: a,
+		input: r,
+		ownerId: $e(e)
+	}));
+	let c = e.workflows;
+	return c && (yield* x.promise(() => c.start(_, {
+		runId: o,
+		flowRef: t.flowRef,
+		input: r,
+		source: s,
+		requestId: a
+	}))), {
+		runId: o,
+		requestId: a,
+		status: "pending"
+	};
+}), tt = (e, t) => x.gen(function* () {
+	let n = yield* $(e, t.runId);
+	if (!n) return yield* x.fail(new b({
+		runId: t.runId,
+		message: "run not found"
+	}));
+	let r = n.requestId ?? Q(), i = n.flowRef, a = n.input ?? {}, o = n.source ?? "manual";
+	yield* x.promise(() => e.store.update(z.tableName, t.runId, {
+		status: "pending",
+		error: null,
+		errorMessage: null
+	}));
+	let s = e.workflows;
+	return s && (yield* x.promise(() => s.start(_, {
+		runId: t.runId,
+		flowRef: i,
+		input: a,
+		source: o,
+		requestId: r
+	}))), {
+		runId: t.runId,
+		requestId: r,
+		status: "pending"
+	};
+}), nt = (e, t) => x.gen(function* () {
+	return (yield* $(e, t.runId)) ? (yield* x.promise(() => e.store.update(z.tableName, t.runId, {
+		status: "cancelled",
+		cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+	})), {
+		runId: t.runId,
+		status: "cancelled"
+	}) : yield* x.fail(new b({
+		runId: t.runId,
+		message: "run not found"
+	}));
+}), rt = (e, t) => x.gen(function* () {
+	let n = yield* $(e, t.runId);
+	if (!n) return yield* x.fail(new b({
+		runId: t.runId,
+		message: "run not found"
+	}));
+	let r = n.status;
+	if (r !== "waiting") return yield* x.fail(new fe({
+		runId: t.runId,
+		status: r ?? "unknown",
+		message: `run is "${r}", not awaiting a response`
+	}));
+	let i = {
+		...t.response,
+		respondedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	yield* x.promise(() => e.store.update(z.tableName, t.runId, { humanResponse: i }));
+	let a = e.workflows, o = n.requestId;
+	return a && o && (yield* x.promise(() => a.signal({
+		workflowName: _,
+		executionId: `flow-run:${o}`
+	}, v, i)).pipe(x.catchAllCause(() => x.void))), { runId: t.runId };
+}), it = (e, t) => x.promise(() => e.store.query(E(R).where(C("id", t.id)).descriptor)).pipe(x.map((e) => e[0])), at = (e) => x.promise(() => e.store.query(E(R).descriptor)), ot = (e, t) => x.promise(() => e.store.insert(R.tableName, {
+	id: t.id ?? `flow-${Q()}`,
+	...t
+})), st = (e, t) => x.promise(() => e.store.update(R.tableName, t.id, t.patch)), ct = (e, t) => x.promise(() => e.store.delete(R.tableName, t.id)), lt = (e = {}) => {
+	let t = e.alias ?? "aiFlows", n = { current: void 0 }, r = (e) => ({
+		kind: "json",
+		data: e
+	}), i = (e, t) => ({
+		kind: "json",
+		status: e,
+		data: { error: t }
+	}), a = (e, t) => x.promise(async () => {
+		let a = n.current;
+		if (!a) return i(503, "store not bound yet");
+		let o = await a.query({
+			table: e,
+			predicate: void 0,
+			order: [],
+			take: t,
+			skip: void 0,
+			projection: void 0
+		});
+		return r({
+			count: o.length,
+			rows: o
+		});
+	}).pipe(x.catchAllCause(() => x.succeed(i(500, "query failed"))));
+	return _e({
+		name: t,
+		description: "AI Flows — durable multi-step AI pipelines (deterministic + agentic) with human-in-the-loop, chaining, and cadence. Code-first (defineFlow) or data-driven.",
+		permissions: ["store:write", "inspect:read"],
+		extendSchema: { tables: B },
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/flows",
+			description: "List flow definitions.",
+			handler: () => a("ai_flows", 200)
+		}, {
+			method: "GET",
+			path: "/runs",
+			description: "List recent flow runs.",
+			handler: () => a("ai_flow_runs", 100)
+		}],
+		bindDataStore: (e) => {
+			n.current = e;
+		}
+	});
+};
+//#endregion
+export { e as BriefField, t as ChainPending, _ as FLOW_RUN_WORKFLOW, n as FlowCadence, r as FlowChain, i as FlowMode, a as FlowStatus, o as FlowStep, v as HUMAN_RESPONSE_SIGNAL, s as HumanResponse, c as Json, l as MAX_STEPS_DEFAULT, u as MAX_STEPS_MAX, d as MAX_STEPS_MIN, f as MediaInputSlot, p as MediaInputs, m as Modality, h as ReviewMode, ee as ReviewOption, te as RunReview, ne as RunSource, re as RunStatus, ie as RunStep, ae as RunStepStatus, oe as StepType, se as Visibility, z as aiFlowRunsTable, lt as aiFlowsPlugin, R as aiFlowsTable, B as aiFlowsTables, Ue as buildFlowRunExecute, ge as cadenceMatches, nt as cancelFlow, ce as clampMaxSteps, je as clearRegistry, V as collectRefs, ot as createFlow, X as cronRequestId, qe as defineFlow, ct as deleteFlow, We as flowStep, it as getFlow, ke as getRegisteredFlow, H as interpolate, et as launchFlow, at as listFlows, Ae as listRegisteredFlows, Qe as makeMediaGenerator, he as nextRuns, g as normalizeFlow, Oe as registerFlow, J as resolveIr, rt as respondToFlow, tt as retryFlow, Ye as runCadenceTick, le as sanitizeOutputKey, De as unresolvedRefs, st as updateFlow, Ke as validateFlow };