@voltro/plugin-ai-flows 0.85.0 → 0.86.0

package/dist/engine.js

@@ -0,0 +1,906 @@
+import { getRegisteredFlow as e } from "./registry.js";
+import { aiFlowRunsTable as t, aiFlowsTable as n } from "./table.js";
+import { humanResponseSignalName as r } from "./workflow.js";
+import { resolveHumanReviewTimeoutMs as i, resolveMaxChainDepth as a } from "./defaults.js";
+import { describeCondition as o, evaluateCondition as s } from "./condition.js";
+import { CostSource as c, HumanResponse as l, MediaArtifacts as u, RunStep as d, StepUsage as f, normalizeFlow as p } from "./ir.js";
+import { interpolate as m, unresolvedRefs as h } from "./interpolate.js";
+import { flowSegments as g } from "./segments.js";
+import { decodeTextParams as _ } from "./textParams.js";
+import { ResolvedMediaInputs as v, resolveMediaInputRefs as y, resolveMediaInputs as b } from "./mediaInputs.js";
+import { decodeMediaResult as x } from "./mediaResult.js";
+import { FlowCapabilityMissing as S, FlowDependencyError as C, FlowNotFound as w } from "./errors.js";
+import { Cause as T, Effect as E, Exit as D, Result as O, Schema as k } from "effect";
+import { and as A, eq as j, queryFor as M } from "@voltro/database";
+import { SuspensionUnavailable as ee, awaitSignalSuspending as te, step as N } from "@voltro/workflow";
+import { defineTool as P, estimateCostUsd as ne, gatewayCostUsd as re, generateObject as ie, generateObjectJson as ae, generateObjectWithTools as oe, generateText as F } from "@voltro/ai";
+//#region src/engine.ts
+var I = (e) => e, se = (e) => e._tag === "FlowAgentUnavailable" ? e.publicMessage ?? "agent unavailable" : "agent not found", L = k.Struct({
+	value: k.optional(k.Unknown),
+	text: k.optional(k.String),
+	url: k.optional(k.String),
+	artifacts: k.optional(u),
+	costMicroUsd: k.optional(k.Number),
+	costSource: k.optional(c),
+	requestId: k.optional(k.String),
+	usage: k.optional(f),
+	error: k.optional(k.String)
+}), R = (e) => x(e).pipe(E.map((e) => {
+	let t = e.artifacts.find((e) => e.role === "primary");
+	return {
+		value: t.url,
+		url: t.url,
+		artifacts: e.artifacts,
+		...e.requestId === void 0 ? {} : { requestId: e.requestId },
+		...e.costMicroUsd === void 0 ? {} : { costMicroUsd: e.costMicroUsd },
+		...e.costSource === void 0 ? {} : { costSource: e.costSource },
+		...e.usage === void 0 ? {} : { usage: e.usage }
+	};
+}), E.catch((e) => E.succeed({ error: e }))), z = (e) => ({
+	...e.requestId ? { requestId: e.requestId } : {},
+	...e.costMicroUsd ? { costMicroUsd: e.costMicroUsd } : {},
+	...e.costSource === void 0 ? {} : { costSource: e.costSource },
+	...e.usage === void 0 ? {} : { usage: e.usage }
+}), B = () => (/* @__PURE__ */ new Date()).toISOString(), ce = (e) => Math.round(e * 1e6), le = (e) => ({
+	name: "gateway",
+	model: e
+}), V = (e, t) => e.resolveModel?.(t) ?? le(t), H = (e, t, n, r) => E.gen(function* () {
+	return t.maxSteps !== void 0 && (!Number.isSafeInteger(t.maxSteps) || t.maxSteps < 1) ? yield* E.fail(new S({
+		capability: "resolveAgent",
+		message: "agent maxSteps must be a positive safe integer"
+	})) : yield* F({
+		...r,
+		system: t.system,
+		prompt: n,
+		provider: V(e, t.model),
+		...t.tools === void 0 ? {} : { tools: t.tools },
+		...t.maxSteps === void 0 ? {} : { maxSteps: t.maxSteps }
+	});
+}), U = (e, t, n) => W(e, t, n).costMicroUsd, W = (e, t, n) => {
+	let r = re(t);
+	if (typeof r == "number") return {
+		costMicroUsd: ce(r),
+		costSource: "gateway"
+	};
+	let i = ne(e, { model: n ?? "unknown" });
+	return {
+		costMicroUsd: i.costMicroUsd ?? 0,
+		costSource: i.costSource ?? "unpriced"
+	};
+}, G = (e) => {
+	let t = e.filter((e) => (e.status === "succeeded" || e.status === "failed") && (e.costSource !== void 0 || e.costMicroUsd !== void 0));
+	if (t.length === 0) return "unknown";
+	let n = t.map((e) => e.costSource ?? "unpriced");
+	return n.every((e) => e === "gateway") ? "actual" : n.some((e) => e === "unpriced") ? "incomplete" : "estimated";
+}, K = (e, n, r) => E.promise(() => e.store.update(t.tableName, n, r).then(() => void 0)).pipe(E.catchCause(() => E.void)), q = (e, n, r, i) => E.promise(async () => {
+	let a = await e.store.query(M(t).where(j("id", n)).descriptor), o = a[0]?.[i];
+	a[0] !== void 0 && o == null && await e.store.update(t.tableName, n, r);
+}).pipe(E.catchCause(() => E.void)), ue = (e, n) => E.promise(async () => {
+	let r = (await e.store.query(M(t).where(j("id", n)).descriptor))[0]?.status;
+	return r === "cancelling" || r === "cancelled";
+}).pipe(E.catchCause(() => E.succeed(!1))), de = (e, n) => E.promise(() => e.store.updateMany(t.tableName, {
+	status: "cancelled",
+	completedAt: B()
+}, { where: A(j("id", n), j("status", "cancelling")) }).then(() => void 0)).pipe(E.catchCause(() => E.void)), J = (t, r) => E.gen(function* () {
+	let i = e(r);
+	if (i) return i;
+	let a = (yield* E.promise(() => t.store.query(M(n).where(j("id", r)).descriptor)))[0];
+	return a ? p({
+		name: a.name ?? r,
+		mode: a.mode,
+		steps: a.steps ?? [],
+		maxSteps: a.maxSteps ?? null,
+		brief: a.inputSchema ?? [],
+		orchestratorModel: a.orchestratorModel ?? null,
+		orchestratorInstructions: a.orchestratorInstructions ?? null,
+		chain: a.chainTo ?? null,
+		cadence: a.cadence ?? null,
+		humanTimeoutMs: a.humanTimeoutMs ?? null
+	}) : yield* E.fail(new w({
+		flowRef: r,
+		message: `no flow registered or stored for "${r}"`
+	}));
+}), Y = (e, t, n, r, i, a) => E.gen(function* () {
+	let e = m(n.prompt ?? "", r), o = n.type === "agent" || n.type === "structured" || n.type === "generate" && (n.modality ?? "text") === "text", s = yield* _(o ? n.params : void 0).pipe(E.result);
+	if (O.isFailure(s)) return { error: `step "${n.id}": ${s.failure}` };
+	if (n.mediaInputs !== void 0 && (n.type !== "generate" || (n.modality ?? "text") === "text")) return { error: `step "${n.id}": media inputs require an image, video or audio generation step` };
+	let c = h(n.prompt ?? "", r);
+	if (c.length > 0) return { error: new C({
+		stepId: n.id,
+		unresolvedRef: c[0],
+		message: `step "${n.id}" references unresolved {{${c[0]}}}`
+	}).message };
+	switch (n.type) {
+		case "note": return {
+			value: e,
+			text: e,
+			costMicroUsd: 0,
+			costSource: "gateway"
+		};
+		case "agent": {
+			if (!n.agentRef) return { error: "agent step missing agentRef" };
+			if (!t.resolveAgent) return { error: new S({
+				capability: "resolveAgent",
+				message: "no agent resolver configured"
+			}).message };
+			let r = yield* I(t.resolveAgent(n.agentRef, i)).pipe(E.map((e) => ({
+				ok: !0,
+				a: e
+			})), E.catch((e) => E.succeed({
+				ok: !1,
+				e
+			})));
+			if (!r.ok) return { error: r.e.message };
+			let a = yield* H(t, r.a, e, s.success).pipe(E.map((e) => ({
+				ok: !0,
+				r: e
+			})), E.catch((e) => E.succeed({
+				ok: !1,
+				e
+			})));
+			return a.ok ? {
+				value: a.r.text,
+				text: a.r.text,
+				...W(a.r.usage, a.r.providerMetadata, r.a.model)
+			} : { error: String(a.e.message ?? a.e) };
+		}
+		case "structured": {
+			if (n.schema === void 0) return { error: `step "${n.id}": structured step requires a JSON Schema` };
+			let r = n.model ?? t.defaultModels?.text, i = yield* ae({
+				...s.success,
+				prompt: e,
+				jsonSchema: n.schema,
+				...r ? { provider: V(t, r) } : {}
+			}).pipe(E.map((e) => ({
+				ok: !0,
+				r: e
+			})), E.catch((e) => E.succeed({
+				ok: !1,
+				e
+			})));
+			return i.ok ? {
+				value: i.r.object,
+				text: JSON.stringify(i.r.object, null, 2),
+				...W(i.r.usage, i.r.providerMetadata, r)
+			} : { error: String(i.e.message ?? i.e) };
+		}
+		case "generate": {
+			let o = n.modality ?? "text";
+			if (o === "text") {
+				let r = n.model ?? t.defaultModels?.text, i = yield* F({
+					...s.success,
+					prompt: e,
+					...r ? { provider: V(t, r) } : {}
+				}).pipe(E.map((e) => ({
+					ok: !0,
+					r: e
+				})), E.catch((e) => E.succeed({
+					ok: !1,
+					e
+				})));
+				return i.ok ? {
+					value: i.r.text,
+					text: i.r.text,
+					...W(i.r.usage, i.r.providerMetadata, r)
+				} : { error: String(i.e.message ?? i.e) };
+			}
+			if (!t.generateMedia) return { error: new S({
+				capability: `media:${o}`,
+				message: `no media generator configured for ${o}`
+			}).message };
+			let c = yield* b(n.mediaInputs, r, a).pipe(E.result);
+			if (O.isFailure(c)) return { error: `step "${n.id}": ${c.failure}` };
+			let l = y(n.mediaInputs, a), u = n.model ?? t.defaultModels?.[o], d = yield* I(t.generateMedia({
+				modality: o,
+				...u ? { model: u } : {},
+				prompt: e,
+				...n.params ? { params: n.params } : {},
+				...n.mediaInputs === void 0 ? {} : { inputs: c.success },
+				...Object.keys(l).length > 0 ? { inputRefs: l } : {},
+				run: i
+			})).pipe(E.map((e) => ({
+				ok: !0,
+				m: e
+			})), E.catch((e) => E.succeed({
+				ok: !1,
+				e
+			})));
+			if (!d.ok) {
+				let e = d.e.receipt;
+				return {
+					error: d.e.message,
+					...e === void 0 ? {} : e
+				};
+			}
+			return yield* R(d.m);
+		}
+		case "human": return { error: new S({
+			capability: "human",
+			message: "human step reached the step interpreter — it should have been parked by the deterministic executor (routing bug)"
+		}).message };
+		default: return { error: `unknown step type: ${String(n.type)}` };
+	}
+}), fe = (e, t, n, a, c, u) => E.gen(function* () {
+	let d = Object.assign(Object.create(null), c), f = Object.create(null), p = a.steps.map((e, t) => ({
+		id: t,
+		title: e.title ?? `Step ${t + 1}`,
+		type: e.type,
+		status: "pending",
+		...e.description ? { description: e.description } : {}
+	})), h = 0;
+	yield* q(e, n, {
+		status: "running",
+		steps: p,
+		totalSteps: a.steps.length,
+		currentStep: 0,
+		startedAt: B()
+	}, "startedAt");
+	for (let c of g(a.steps)) {
+		if (yield* ue(e, n)) return yield* de(e, n), {
+			runId: n,
+			status: "cancelled"
+		};
+		if (c.steps.length > 1) {
+			let r = [];
+			for (let { index: e, step: t } of c.steps) t.when !== void 0 && !s(t.when, d) ? p[e] = {
+				...p[e],
+				status: "skipped",
+				completedAt: B(),
+				skipReason: o(t.when)
+			} : (r.push({
+				index: e,
+				step: t
+			}), p[e] = {
+				...p[e],
+				status: "running",
+				startedAt: B()
+			});
+			yield* K(e, n, {
+				steps: p,
+				currentStep: c.steps[0].index
+			});
+			let i = yield* E.all(r.map(({ index: r, step: i }) => N({
+				name: `flow-${r}-${i.id}`,
+				input: { index: r },
+				success: L,
+				execute: Y(e, t, i, d, {
+					runId: n,
+					tenantId: u.tenantId,
+					ownerId: u.ownerId
+				}, f)
+			}).pipe(E.map((e) => ({
+				index: r,
+				step: i,
+				result: e
+			})))), { concurrency: "unbounded" }), a = i.find((e) => e.result.error);
+			for (let { index: e, step: t, result: n } of i) n.error ? (h += n.costMicroUsd ?? 0, p[e] = {
+				...p[e],
+				status: "failed",
+				completedAt: B(),
+				errorMessage: n.error,
+				...z(n)
+			}) : (t.outputKey && n.value !== void 0 && (d[t.outputKey] = n.value), t.outputKey && n.artifacts !== void 0 && (f[t.outputKey] = n.artifacts), h += n.costMicroUsd ?? 0, p[e] = {
+				...p[e],
+				status: "succeeded",
+				completedAt: B(),
+				...n.text ? { output: { text: n.text } } : {},
+				...n.url ? { url: n.url } : {},
+				...n.artifacts === void 0 ? {} : { artifacts: n.artifacts },
+				...z(n)
+			});
+			if (a !== void 0) return yield* K(e, n, {
+				steps: p,
+				status: "failed",
+				errorMessage: a.result.error,
+				completedAt: B(),
+				costMicroUsd: h,
+				costCompleteness: G(p)
+			}), {
+				runId: n,
+				status: "failed"
+			};
+			yield* K(e, n, {
+				steps: p,
+				currentStep: c.steps[c.steps.length - 1].index + 1,
+				costMicroUsd: h,
+				costCompleteness: G(p)
+			});
+			continue;
+		}
+		let { index: g, step: _ } = c.steps[0];
+		if (_.when !== void 0 && !s(_.when, d)) {
+			p[g] = {
+				...p[g],
+				status: "skipped",
+				completedAt: B(),
+				skipReason: o(_.when)
+			}, yield* K(e, n, {
+				steps: p,
+				currentStep: g + 1
+			});
+			continue;
+		}
+		if (_.type === "human") {
+			let o = {
+				mode: _.reviewMode ?? "approve",
+				..._.options ? { options: _.options } : {},
+				prompt: m(_.prompt ?? "", d)
+			};
+			p[g] = {
+				...p[g],
+				status: "waiting",
+				startedAt: B(),
+				review: o
+			}, yield* K(e, n, {
+				steps: p,
+				status: "waiting",
+				currentStep: g
+			}), t.onEvent && (yield* I(t.onEvent({
+				kind: "review-needed",
+				runId: n,
+				flowName: a.name,
+				ownerId: u.ownerId,
+				source: u.source
+			})).pipe(E.catchCause(() => E.void)));
+			let s = i({
+				step: _,
+				flow: a,
+				deps: t
+			}), c = yield* te(e, {
+				name: r(g),
+				schema: l,
+				timeoutMs: s
+			}).pipe(E.map((e) => ({
+				ok: !0,
+				a: e
+			})), E.catchCause((e) => T.hasInterruptsOnly(e) ? E.failCause(e) : E.succeed({
+				ok: !1,
+				cause: e
+			})));
+			if (!c.ok) {
+				let t = Number.isFinite(s) ? `human review timed out after ${s}ms` : "human review failed";
+				return p[g] = {
+					...p[g],
+					status: "failed",
+					completedAt: B(),
+					errorMessage: t
+				}, yield* K(e, n, {
+					steps: p,
+					status: "failed",
+					errorMessage: t,
+					completedAt: B(),
+					costMicroUsd: h,
+					costCompleteness: G(p)
+				}), {
+					runId: n,
+					status: "failed"
+				};
+			}
+			let f = c.a;
+			if (f.decision === "reject") return p[g] = {
+				...p[g],
+				status: "failed",
+				completedAt: B(),
+				errorMessage: "rejected by reviewer"
+			}, yield* K(e, n, {
+				steps: p,
+				status: "cancelled",
+				humanResponse: f,
+				completedAt: B(),
+				costMicroUsd: h,
+				costCompleteness: G(p)
+			}), {
+				runId: n,
+				status: "cancelled"
+			};
+			_.outputKey && (d[_.outputKey] = f.value ?? f.text ?? f.decision ?? !0), p[g] = {
+				...p[g],
+				status: "succeeded",
+				completedAt: B(),
+				output: { text: String(f.text ?? f.value ?? f.decision ?? "approved") }
+			}, yield* K(e, n, {
+				steps: p,
+				status: "running",
+				humanResponse: f,
+				currentStep: g + 1
+			});
+			continue;
+		}
+		p[g] = {
+			...p[g],
+			status: "running",
+			startedAt: B()
+		}, yield* K(e, n, {
+			steps: p,
+			currentStep: g
+		});
+		let v = yield* N({
+			name: `flow-${g}-${_.id}`,
+			input: { index: g },
+			success: L,
+			execute: Y(e, t, _, d, {
+				runId: n,
+				tenantId: u.tenantId,
+				ownerId: u.ownerId
+			}, f)
+		});
+		if (v.error) return h += v.costMicroUsd ?? 0, p[g] = {
+			...p[g],
+			status: "failed",
+			completedAt: B(),
+			errorMessage: v.error,
+			...z(v)
+		}, yield* K(e, n, {
+			steps: p,
+			status: "failed",
+			errorMessage: v.error,
+			completedAt: B(),
+			costMicroUsd: h,
+			costCompleteness: G(p)
+		}), {
+			runId: n,
+			status: "failed"
+		};
+		_.outputKey && v.value !== void 0 && (d[_.outputKey] = v.value), _.outputKey && v.artifacts !== void 0 && (f[_.outputKey] = v.artifacts), h += v.costMicroUsd ?? 0, p[g] = {
+			...p[g],
+			status: "succeeded",
+			completedAt: B(),
+			...v.text ? { output: { text: v.text } } : {},
+			...v.url ? { url: v.url } : {},
+			...v.artifacts === void 0 ? {} : { artifacts: v.artifacts },
+			...z(v)
+		}, yield* K(e, n, {
+			steps: p,
+			currentStep: g + 1,
+			costMicroUsd: h,
+			costCompleteness: G(p)
+		});
+	}
+	let _ = Object.create(null);
+	for (let e of a.steps) e.outputKey && d[e.outputKey] !== void 0 && (_[e.outputKey] = d[e.outputKey]);
+	return yield* K(e, n, {
+		status: "succeeded",
+		output: _,
+		completedAt: B(),
+		costMicroUsd: h
+	}), {
+		runId: n,
+		status: "succeeded",
+		output: _
+	};
+}), pe = (e, n, r, i, o, s, c) => E.gen(function* () {
+	let l = r.chain;
+	if (!l) return;
+	let u = [...s.chainPath ?? [], s.flowRef];
+	if (l.flowRef === r.name || l.flowRef === s.flowRef) return;
+	if (u.includes(l.flowRef)) {
+		yield* K(e, n, { chainRefusal: `chain to "${l.flowRef}" refused — it is already in this run's chain (${u.join(" → ")}), which would loop` });
+		return;
+	}
+	let d = a(c);
+	if (u.length >= d) {
+		yield* K(e, n, { chainRefusal: `chain to "${l.flowRef}" refused — depth ${u.length} reached the limit of ${d} (${u.join(" → ")})` });
+		return;
+	}
+	let f = {
+		...i,
+		...o
+	}, p = {};
+	for (let e of l.mappings) e.sourceKey in f && (p[e.targetKey] = f[e.sourceKey]);
+	if (l.requireConfirmation) {
+		yield* K(e, n, { chainPending: {
+			flowRef: l.flowRef,
+			input: p,
+			status: "pending"
+		} });
+		return;
+	}
+	let m = e.workflows;
+	if (!m) return;
+	let h = `${n}--chain`, g = `${s.requestId}--chain`;
+	yield* E.promise(async () => {
+		try {
+			await e.store.insert(t.tableName, {
+				id: h,
+				flowRef: l.flowRef,
+				flowName: l.flowRef,
+				status: "pending",
+				source: s.source,
+				requestId: g,
+				input: p
+			});
+		} catch {}
+		await m.child("flow.run", {
+			runId: h,
+			flowRef: l.flowRef,
+			input: p,
+			source: s.source,
+			requestId: g,
+			chainPath: u
+		});
+	}).pipe(E.catchCause(() => E.void));
+}), me = (e) => e.type === "agent" ? e.agentRef ? `agent step, agent "${e.agentRef}"` : "agent step" : e.type === "generate" ? `${e.modality ?? "media"} generation step` : `${e.type} step`, he = (e) => e.steps.length === 0 ? "" : "Suggested plan (you MAY reorder, insert, or skip steps):\n" + e.steps.map((e, t) => `${t + 1}. ${e.title ?? e.id}${e.prompt ? `: ${e.prompt}` : ""} (${me(e)})`).join("\n"), ge = "an agentic flow runs its planner and every tool inside one durable step, which cannot park. Call the provider directly from the tool (generateImage, generateVideo, …), or give the work its own deterministic flow step", X = k.optional(k.String.annotate({ description: "One short sentence: what this call is for. Shown to the user in the run timeline." })), Z = (e) => e === void 0 || e.trim() === "" ? {} : { description: e.trim().slice(0, 200) }, Q = k.Struct({ json: k.String.annotate({ description: "The requested JSON object, serialized as a JSON string." }) }), _e = (e) => {
+	try {
+		let t = JSON.parse(e);
+		return typeof t == "object" && t && !Array.isArray(t) ? t : void 0;
+	} catch {
+		return;
+	}
+}, ve = (e) => {
+	if (D.isSuccess(e)) return "the tool returned without recording a result";
+	if (T.hasInterruptsOnly(e.cause)) return "interrupted before it finished — nothing waited for its result";
+	let t = T.squash(e.cause);
+	return t instanceof Error ? t.message : String(t);
+}, ye = (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");
+}, $ = (e) => [
+	e.orchestrator?.instructions ?? "You are an orchestrator that uses the available tools to produce a bundled result.",
+	he(e),
+	"When finished, emit a JSON object mapping each deliverable name (outputKey) to its value, serialized as a string in the json field."
+].filter(Boolean).join("\n\n"), be = k.Struct({
+	object: k.Record(k.String, k.Unknown),
+	planCostMicroUsd: k.Number,
+	planCostSource: k.optional(c),
+	toolCostMicroUsd: k.Number,
+	steps: k.Array(d),
+	error: k.optional(k.String)
+}), xe = (e, t, n, r, i, a, o, s) => E.gen(function* () {
+	yield* q(e, n, {
+		status: "running",
+		startedAt: B(),
+		totalSteps: r.steps.length
+	}, "startedAt");
+	let c = yield* N({
+		name: "flow-agentic",
+		input: { flowRef: r.name },
+		success: be,
+		execute: E.gen(function* () {
+			let c = [], l = 0, u = (e) => {
+				let t = c.length;
+				return c.push({
+					id: t,
+					status: "running",
+					startedAt: B(),
+					...e
+				}), t;
+			}, d = (e, t) => {
+				c[e] = {
+					...c[e],
+					completedAt: B(),
+					...t
+				};
+			}, f = () => K(e, n, {
+				steps: c,
+				currentStep: c.length,
+				costMicroUsd: l
+			}), p = (e, t) => E.suspend(() => {
+				let n = u(e);
+				return E.andThen(f(), t(n)).pipe(E.onExit((e) => c[n]?.status === "running" ? (d(n, {
+					status: "failed",
+					errorMessage: ve(e)
+				}), E.ignore(f())) : E.void));
+			}), m = yield* (t.listAgents ? I(t.listAgents({
+				runId: n,
+				tenantId: o,
+				ownerId: a
+			})) : E.succeed(void 0)).pipe(E.result);
+			if (O.isFailure(m)) return yield* E.logWarning(`flow agent listing failed for run ${n}: ${m.failure.message}`).pipe(E.annotateLogs({ scope: "voltro:ai-flows" })), {
+				object: {},
+				planCostMicroUsd: 0,
+				toolCostMicroUsd: 0,
+				steps: c,
+				error: "flow agent listing failed"
+			};
+			let h = m.success, g = h ?? [...new Set(r.steps.flatMap((e) => e.type === "agent" && e.agentRef ? [e.agentRef] : []))].map((e) => ({ ref: e })), _ = g.map((e) => e.ref), y = _.length > 0 ? k.Literals(_) : k.String, b = P({
+				name: "run_agent",
+				description: "Delegate a text task to an allowed sub-agent. Returns the agent's text." + (g.length > 0 ? ` Agents you may call: ${g.map((e) => e.description ? `${e.ref} (${e.description})` : e.ref).join("; ")}.` : ""),
+				input: k.Struct({
+					agentRef: y,
+					prompt: k.String,
+					purpose: X
+				}),
+				execute: ({ agentRef: e, prompt: r, purpose: i }) => p({
+					title: `agent:${e}`,
+					type: "agent",
+					agentRef: e,
+					...Z(i)
+				}, (i) => E.gen(function* () {
+					if (!t.resolveAgent) return d(i, {
+						status: "failed",
+						errorMessage: "no agent resolver configured"
+					}), yield* f(), "ERROR: no agent resolver configured";
+					let s = yield* I(t.resolveAgent(e, {
+						runId: n,
+						tenantId: o,
+						ownerId: a
+					})).pipe(E.map((e) => ({
+						ok: !0,
+						a: e
+					})), E.catch((e) => E.succeed({
+						ok: !1,
+						e
+					})));
+					if (!s.ok) return d(i, {
+						status: "failed",
+						errorMessage: s.e.message
+					}), yield* f(), `ERROR: ${se(s.e)}`;
+					let c = yield* H(t, s.a, r, {}).pipe(E.map((e) => ({
+						ok: !0,
+						r: e
+					})), E.catch((e) => E.succeed({
+						ok: !1,
+						e
+					})));
+					if (!c.ok) {
+						let e = String(c.e.message ?? c.e);
+						return d(i, {
+							status: "failed",
+							errorMessage: e
+						}), yield* f(), `ERROR: ${e}`;
+					}
+					let u = U(c.r.usage, c.r.providerMetadata, s.a.model);
+					return l += u, d(i, {
+						status: "succeeded",
+						output: { text: c.r.text },
+						costMicroUsd: u
+					}), yield* f(), c.r.text;
+				}))
+			}), x = P({
+				name: "generate_media",
+				description: "Generate image, video, or audio artifacts. Returns every artifact with its URL, role, media type and optional storage reference.",
+				input: k.Struct({
+					modality: k.Literals([
+						"image",
+						"video",
+						"audio"
+					]),
+					prompt: k.String,
+					purpose: X,
+					model: k.optional(k.String),
+					inputs: k.optional(v),
+					params: k.optional(k.Record(k.String, k.Unknown))
+				}),
+				execute: ({ modality: e, prompt: r, purpose: i, model: s, inputs: c, params: u }) => p({
+					title: `media:${e}`,
+					type: "generate",
+					modality: e,
+					...Z(i)
+				}, (i) => E.gen(function* () {
+					if (!t.generateMedia) return d(i, {
+						status: "failed",
+						errorMessage: `no media generator for ${e}`
+					}), yield* f(), `ERROR: no media generator configured for ${e}`;
+					let p = yield* I(t.generateMedia({
+						modality: e,
+						prompt: r,
+						...s ? { model: s } : {},
+						...c === void 0 ? {} : { inputs: c },
+						...u === void 0 ? {} : { params: u },
+						run: {
+							runId: n,
+							tenantId: o,
+							ownerId: a
+						}
+					})).pipe(E.map((e) => ({
+						ok: !0,
+						r: e
+					})), E.catch((e) => E.succeed({
+						ok: !1,
+						e
+					})));
+					if (!p.ok) return d(i, {
+						status: "failed",
+						errorMessage: p.e.message
+					}), yield* f(), `ERROR: ${p.e.message}`;
+					let m = yield* R(p.r);
+					return m.error ? (d(i, {
+						status: "failed",
+						errorMessage: m.error
+					}), yield* f(), { error: m.error }) : (l += m.costMicroUsd ?? 0, d(i, {
+						status: "succeeded",
+						url: m.url,
+						artifacts: m.artifacts,
+						...m.requestId ? { requestId: m.requestId } : {},
+						costMicroUsd: m.costMicroUsd ?? 0,
+						costSource: m.costSource ?? "unpriced"
+					}), yield* f(), { artifacts: m.artifacts });
+				}))
+			}), S = P({
+				name: "pick_structured",
+				description: "Produce a JSON object for a task. Returns the object.",
+				input: k.Struct({
+					prompt: k.String,
+					purpose: X,
+					model: k.optional(k.String)
+				}),
+				execute: ({ prompt: e, purpose: n, model: r }) => p({
+					title: "structured",
+					type: "structured",
+					...Z(n)
+				}, (n) => E.gen(function* () {
+					let i = yield* ie({
+						prompt: `${e}\n\nReturn the JSON object serialized as a string in the \`json\` field.`,
+						schema: Q,
+						...r ? { provider: V(t, r) } : {}
+					}).pipe(E.map((e) => ({
+						ok: !0,
+						r: e
+					})), E.catch((e) => E.succeed({
+						ok: !1,
+						e
+					})));
+					if (!i.ok) {
+						let e = String(i.e.message ?? i.e);
+						return d(n, {
+							status: "failed",
+							errorMessage: e
+						}), yield* f(), { error: e };
+					}
+					let a = U(i.r.usage, i.r.providerMetadata, r);
+					l += a;
+					let o = _e(i.r.object.json);
+					if (o === void 0) {
+						let e = "the model's `json` field is not a JSON object";
+						return d(n, {
+							status: "failed",
+							errorMessage: e,
+							costMicroUsd: a
+						}), yield* f(), { error: e };
+					}
+					return d(n, {
+						status: "succeeded",
+						output: { text: JSON.stringify(o) },
+						costMicroUsd: a
+					}), yield* f(), o;
+				}))
+			}), C = {
+				run_agent: b,
+				generate_media: x,
+				pick_structured: S
+			}, w = yield* (t.resolveTools ? I(t.resolveTools(s, {
+				runId: n,
+				tenantId: o,
+				ownerId: a
+			}, { provider: () => r.orchestrator?.model ? V(t, r.orchestrator.model) : void 0 })) : E.succeed({})).pipe(E.result);
+			if (O.isFailure(w)) return yield* E.logWarning(`flow tool resolution failed for run ${n}: ${w.failure.message}`).pipe(E.annotateLogs({ scope: "voltro:ai-flows" })), {
+				object: {},
+				planCostMicroUsd: 0,
+				toolCostMicroUsd: 0,
+				steps: c,
+				error: "flow tool resolution failed"
+			};
+			if (Object.keys(w.success).some((e) => Object.hasOwn(C, e))) return {
+				object: {},
+				planCostMicroUsd: 0,
+				toolCostMicroUsd: 0,
+				steps: c,
+				error: "flow tools cannot replace reserved planner tools"
+			};
+			let T = t.memoryPrefix ? yield* I(t.memoryPrefix(a)).pipe(E.catch(() => E.succeed(""))) : "", D = T ? `${T}\n\n${$(r)}` : $(r), A = yield* oe({
+				system: D,
+				prompt: ye(i),
+				schema: Q,
+				tools: {
+					...w.success,
+					...h?.length === 0 ? {
+						generate_media: x,
+						pick_structured: S
+					} : C
+				},
+				maxSteps: r.maxSteps,
+				...r.orchestrator?.model ? { provider: V(t, r.orchestrator.model) } : {}
+			}).pipe(E.provideService(ee, ge), E.map((e) => ({
+				ok: !0,
+				r: e
+			})), E.catch((e) => E.succeed({
+				ok: !1,
+				e
+			})));
+			for (let e of c) e.status === "running" && d(e.id, {
+				status: "failed",
+				errorMessage: "not finished — the run ended first"
+			});
+			if (!A.ok) return {
+				object: {},
+				planCostMicroUsd: 0,
+				toolCostMicroUsd: l,
+				steps: c,
+				error: String(A.e.message ?? A.e)
+			};
+			let j = _e(A.r.object.json);
+			return {
+				object: j ?? {},
+				...j === void 0 ? { error: "the planner's `json` field is not a JSON object" } : {},
+				planCostMicroUsd: U(A.r.usage, A.r.providerMetadata, r.orchestrator?.model),
+				planCostSource: W(A.r.usage, A.r.providerMetadata, r.orchestrator?.model).costSource,
+				toolCostMicroUsd: l,
+				steps: c
+			};
+		})
+	}), l = c.planCostMicroUsd + c.toolCostMicroUsd, u = G([...c.steps, {
+		status: "succeeded",
+		costMicroUsd: c.planCostMicroUsd,
+		costSource: c.planCostSource ?? "unpriced"
+	}]);
+	return c.error ? (yield* K(e, n, {
+		status: "failed",
+		steps: c.steps,
+		errorMessage: c.error,
+		completedAt: B(),
+		costMicroUsd: l,
+		costCompleteness: u
+	}), {
+		runId: n,
+		status: "failed"
+	}) : (yield* K(e, n, {
+		status: "succeeded",
+		steps: c.steps,
+		output: c.object,
+		completedAt: B(),
+		costMicroUsd: l,
+		costCompleteness: u
+	}), {
+		runId: n,
+		status: "succeeded",
+		output: c.object
+	});
+}), Se = (e, n = {}) => (r, i) => E.gen(function* () {
+	let { runId: i, flowRef: a, input: o } = r, s = yield* E.tryPromise(() => e.store.query(M(t).where(j("id", i)).descriptor)).pipe(E.flatMap(k.decodeUnknownEffect(k.Tuple([k.Struct({
+		id: k.Literal(i),
+		tenantId: k.NullOr(k.NonEmptyString),
+		ownerId: k.optional(k.NullOr(k.String))
+	})]))), E.result);
+	if (O.isFailure(s)) return yield* K(e, i, {
+		status: "failed",
+		errorMessage: "flow run context unavailable: expected one matching run row with an explicit tenantId (string or null)",
+		completedAt: B()
+	}), {
+		runId: i,
+		status: "failed"
+	};
+	let { tenantId: c, ownerId: l = null } = s.success[0], u = yield* N({
+		name: "flow-0-resolve",
+		input: { flowRef: a },
+		success: k.Struct({
+			ir: k.Unknown,
+			error: k.optional(k.String)
+		}),
+		execute: J(e, a).pipe(E.flatMap((e) => {
+			for (let t of e.steps) {
+				if (!(t.type === "agent" || t.type === "structured" || t.type === "generate" && (t.modality ?? "text") === "text") || t.params === void 0) continue;
+				let e = E.runSyncExit(_(t.params));
+				if (D.isFailure(e)) return E.succeed({
+					ir: null,
+					error: `step "${t.id}": ${T.squash(e.cause)}`
+				});
+			}
+			return E.succeed({ ir: JSON.parse(JSON.stringify(e)) });
+		}), E.catch((e) => E.succeed({
+			ir: null,
+			error: e.message
+		})))
+	});
+	if (u.error || !u.ir) return yield* K(e, i, {
+		status: "failed",
+		errorMessage: u.error ?? "flow not found",
+		completedAt: B()
+	}), {
+		runId: i,
+		status: "failed"
+	};
+	let d = u.ir, f = d.mode === "agentic" ? yield* xe(e, n, i, d, o, l, c, a) : yield* fe(e, n, i, d, o, {
+		ownerId: l,
+		tenantId: c,
+		source: r.source
+	});
+	return f.status === "succeeded" && d.chain && (yield* pe(e, i, d, o, f.output ?? {}, r, n)), n.onEvent && (f.status === "succeeded" || f.status === "failed") && (yield* I(n.onEvent({
+		kind: f.status,
+		runId: i,
+		flowName: d.name,
+		ownerId: l,
+		source: r.source
+	})).pipe(E.catchCause(() => E.void))), f;
+});
+//#endregion
+export { Se as buildFlowRunExecute, J as resolveIr };