@voltro/plugin-ai-flows 0.73.0 → 0.75.0

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

@@ -108,6 +108,16 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	options: e.optional(e.Array(_)),
 	prompt: e.String
 }), k = e.Literal("gateway", "estimated", "unpriced"), A = e.Literal("actual", "estimated", "incomplete", "unknown"), j = 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({
+	costMicroUsd: e.optional(e.Finite.pipe(e.nonNegative())),
+	costSource: e.optional(k),
+	requestId: e.optional(e.NonEmptyString),
+	usage: e.optional(j)
+}), N = e.Struct({
 	id: e.Number,
 	title: e.String,
 	description: e.optional(e.String),
@@ -118,35 +128,36 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	costMicroUsd: e.optional(e.Number),
 	costSource: e.optional(k),
 	requestId: e.optional(e.String),
+	usage: e.optional(j),
 	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(O)
-}), M = e.Struct({
+}), P = e.Struct({
 	decision: e.optional(e.Literal("approve", "reject")),
 	value: e.optional(e.String),
 	text: e.optional(e.String),
 	respondedAt: e.optional(e.String)
-}), N = e.Struct({
+}), F = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
-	response: M
-}), P = e.Struct({
+	response: P
+}), I = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
 	executionId: e.NonEmptyString,
 	eventId: e.NonEmptyString,
 	status: e.Literal("accepted")
-}), F = e.Struct({
+}), L = e.Struct({
 	flowRef: e.String,
 	input: b,
 	status: e.Literal("pending", "confirmed", "dismissed")
-}), I = 30, L = 1, R = 100, z = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), B = (e) => e.replace(/[^\w.-]/g, "_"), V = (e) => {
+}), 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) => {
 	let t = (e.steps ?? []).map((e) => e.outputKey ? {
 		...e,
-		outputKey: B(e.outputKey)
+		outputKey: H(e.outputKey)
 	} : e), n = e.orchestratorModel || e.orchestratorInstructions ? {
 		...e.orchestratorModel ? { model: e.orchestratorModel } : {},
 		...e.orchestratorInstructions ? { instructions: e.orchestratorInstructions } : {}
@@ -155,7 +166,7 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		name: e.name,
 		mode: e.mode ?? "deterministic",
 		steps: t,
-		maxSteps: z(e.maxSteps),
+		maxSteps: V(e.maxSteps),
 		brief: e.brief ?? [],
 		...n ? { orchestrator: n } : {},
 		...e.chain ? { chain: e.chain } : {},
@@ -164,4 +175,4 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	};
 };
 //#endregion
-export { m as A, g as C, f as D, p as E, n as F, r as I, s as L, z as M, V as N, j as O, B as P, o as R, h as S, O as T, L as _, E as a, v as b, N as c, u as d, C as f, R as g, I as h, k as i, d as j, D as k, P as l, b as m, F as n, T as o, M as p, A as r, l as s, w as t, c as u, x as v, _ as w, y as x, S as y, i as z };
+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 };

package/dist/ir.d.ts

@@ -412,6 +412,26 @@ export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
 
 export declare type MediaInputSlot = typeof MediaInputSlot.Type;
 
+/**
+ * The evidence of a charge that happened BEFORE a step failed — a provider that
+ * generated (and billed) while a later part of the step, typically storing the
+ * artifact, did not succeed. A failed step that carries one is priced like a
+ * succeeded one; the run's `costCompleteness` counts it.
+ */
+export declare const MediaReceipt: Schema.Struct<{
+    costMicroUsd: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
+    requestId: Schema.optional<typeof Schema.NonEmptyString>;
+    usage: Schema.optional<Schema.Struct<{
+        status: Schema.Literal<["reported", "unreported"]>;
+        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
+        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    }>>;
+}>;
+
+export declare type MediaReceipt = typeof MediaReceipt.Type;
+
 export declare const Modality: Schema.Literal<["text", "image", "video", "audio"]>;
 
 export declare type Modality = typeof Modality.Type;
@@ -473,6 +493,13 @@ export declare const RunStep: Schema.Struct<{
     costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
     /** Links a media step to its generation/usage record. */
     requestId: Schema.optional<typeof Schema.String>;
+    /** What the step consumed — also on a FAILED step that was charged. */
+    usage: Schema.optional<Schema.Struct<{
+        status: Schema.Literal<["reported", "unreported"]>;
+        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
+        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    }>>;
     /** 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. */
@@ -515,6 +542,8 @@ export declare interface RunStep {
     readonly costMicroUsd?: number | undefined;
     readonly costSource?: CostSource | undefined;
     readonly requestId?: string | undefined;
+    /** What the step consumed — also on a FAILED step that was charged. */
+    readonly usage?: StepUsage | undefined;
     readonly url?: string | undefined;
     readonly artifacts?: ReadonlyArray<MediaArtifact> | undefined;
     readonly output?: {
@@ -556,6 +585,25 @@ export declare const StepType: Schema.Literal<["agent", "generate", "structured"
 
 export declare type StepType = typeof StepType.Type;
 
+/**
+ * What a step CONSUMED, in the provider's own unit — the quantity a cost was, or
+ * could have been, priced from. `reported`: the provider said so. `unreported`:
+ * the call returned no tally, so there is nothing to price and nothing to
+ * dispute, and saying that is different from saying zero.
+ *
+ * Without it a step priced `unpriced` read the same whether the provider had
+ * reported 7/150 tokens or nothing at all — and only the first can be priced
+ * later, or reconciled against an invoice.
+ */
+export declare const StepUsage: Schema.Struct<{
+    status: Schema.Literal<["reported", "unreported"]>;
+    unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
+    input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+}>;
+
+export declare type StepUsage = typeof StepUsage.Type;
+
 /** Gallery scope. `shared` → per-subject share list; `organization` → tenant. */
 export declare const Visibility: Schema.Literal<["private", "organization", "shared"]>;
 

package/dist/ir.js

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

package/dist/web.d.ts

@@ -428,6 +428,13 @@ export declare const RunStep: Schema.Struct<{
     costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
     /** Links a media step to its generation/usage record. */
     requestId: Schema.optional<typeof Schema.String>;
+    /** What the step consumed — also on a FAILED step that was charged. */
+    usage: Schema.optional<Schema.Struct<{
+        status: Schema.Literal<["reported", "unreported"]>;
+        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
+        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    }>>;
     /** 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. */
@@ -470,6 +477,8 @@ export declare interface RunStep {
     readonly costMicroUsd?: number | undefined;
     readonly costSource?: CostSource | undefined;
     readonly requestId?: string | undefined;
+    /** What the step consumed — also on a FAILED step that was charged. */
+    readonly usage?: StepUsage | undefined;
     readonly url?: string | undefined;
     readonly artifacts?: ReadonlyArray<MediaArtifact> | undefined;
     readonly output?: {
@@ -506,6 +515,25 @@ export declare const StepType: Schema.Literal<["agent", "generate", "structured"
 
 export declare type StepType = typeof StepType.Type;
 
+/**
+ * What a step CONSUMED, in the provider's own unit — the quantity a cost was, or
+ * could have been, priced from. `reported`: the provider said so. `unreported`:
+ * the call returned no tally, so there is nothing to price and nothing to
+ * dispute, and saying that is different from saying zero.
+ *
+ * Without it a step priced `unpriced` read the same whether the provider had
+ * reported 7/150 tokens or nothing at all — and only the first can be priced
+ * later, or reconciled against an invoice.
+ */
+declare const StepUsage: Schema.Struct<{
+    status: Schema.Literal<["reported", "unreported"]>;
+    unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
+    input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+}>;
+
+declare type StepUsage = typeof StepUsage.Type;
+
 /** Cooperatively cancel a run (the engine stops before its next step). */
 export declare const useCancelFlow: (options?: FlowHookOptions) => {
     cancel: (runId: string) => Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-ai-flows",
-  "version": "0.73.0",
+  "version": "0.75.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,16 +58,16 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/ai": "0.73.0",
-    "@voltro/client": "0.73.0",
-    "@voltro/database": "0.73.0",
-    "@voltro/env": "0.73.0",
-    "@voltro/plugin-audit": "0.73.0",
-    "@voltro/plugin-multitenancy": "0.73.0",
-    "@voltro/plugin-soft-delete": "0.73.0",
-    "@voltro/protocol": "0.73.0",
-    "@voltro/runtime": "0.73.0",
-    "@voltro/workflow": "0.73.0"
+    "@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"
   },
   "peerDependencies": {
     "effect": "^3.22.1"