@voltro/plugin-ai-flows 0.74.0 → 0.76.0

package/THIRD-PARTY-NOTICES.md

@@ -9,7 +9,7 @@ Generated from the resolved runtime dependency closure (73 packages).
 
 ---
 
-## @ai-sdk/anthropic@4.0.49
+## @ai-sdk/anthropic@4.0.56
 
 License: Apache-2.0
 
@@ -29,7 +29,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ```
 
-## @ai-sdk/openai@4.0.58
+## @ai-sdk/openai@4.0.69
 
 License: Apache-2.0
 
@@ -49,7 +49,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ```
 
-## @ai-sdk/provider@4.0.10
+## @ai-sdk/provider@4.0.17
 
 License: Apache-2.0
 
@@ -69,7 +69,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ```
 
-## @ai-sdk/provider-utils@5.0.36
+## @ai-sdk/provider-utils@5.0.43
 
 License: Apache-2.0
 
@@ -131,7 +131,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @effect/platform-node@0.108.1
+## @effect/platform-node@0.108.2
 
 License: MIT
 
@@ -3616,7 +3616,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @upstash/redis@1.38.3
+## @upstash/redis@1.38.4
 
 License: MIT
 
@@ -4377,7 +4377,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## jose@6.2.10
+## jose@6.2.12
 
 License: MIT
 

package/dist/errors.d.ts

@@ -39,6 +39,21 @@ declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapability
 } & {
     capability: typeof Schema.String;
     message: typeof Schema.String;
+    /** A charge that happened before the failure — the generation succeeded and
+     *  was billed, then storing its artifact did not. The engine records it on
+     *  the failed step, so the run's cost is not reported as unknown when it is
+     *  merely incomplete. */
+    receipt: Schema.optional<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>>;
+        }>>;
+    }>>;
 }>;
 
 /** A step's input still contains an unresolved `{{ref}}` (its producing step

package/dist/errors.js

@@ -1,38 +1,40 @@
-import { Schema as e } from "effect";
+import { C as e } from "./ir-BW5JRUiH.js";
+import { Schema as t } from "effect";
 //#region src/errors.ts
-var t = class extends e.TaggedError()("FlowNotFound", {
-	flowRef: e.String,
-	message: e.String
-}) {}, n = class extends e.TaggedError()("FlowRunNotFound", {
-	runId: e.String,
-	message: e.String
-}) {}, r = class extends e.TaggedError()("FlowValidationError", {
-	flowRef: e.String,
-	message: e.String,
-	issues: e.optional(e.Array(e.String))
-}) {}, i = class extends e.TaggedError()("FlowDependencyError", {
-	stepId: e.String,
-	unresolvedRef: e.String,
-	message: e.String
-}) {}, a = class extends e.TaggedError()("FlowBriefIncomplete", {
-	missing: e.Array(e.String),
-	message: e.String
-}) {}, o = class extends e.TaggedError()("FlowNotAwaitingResponse", {
-	runId: e.String,
-	status: e.String,
-	message: e.String
-}) {}, s = class extends e.TaggedError()("FlowReviewDeliveryError", {
-	runId: e.String,
-	reason: e.Literal("runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"),
-	message: e.String
-}) {}, c = class extends e.TaggedError()("FlowCapabilityMissing", {
-	capability: e.String,
-	message: e.String
-}) {}, l = class extends e.TaggedError()("FlowAgentUnavailable", {
-	agentRef: e.String,
-	reason: e.Literal("not-found", "access-revoked", "model-unusable"),
-	message: e.String,
-	publicMessage: e.optional(e.String)
+var n = class extends t.TaggedError()("FlowNotFound", {
+	flowRef: t.String,
+	message: t.String
+}) {}, r = class extends t.TaggedError()("FlowRunNotFound", {
+	runId: t.String,
+	message: t.String
+}) {}, i = class extends t.TaggedError()("FlowValidationError", {
+	flowRef: t.String,
+	message: t.String,
+	issues: t.optional(t.Array(t.String))
+}) {}, a = class extends t.TaggedError()("FlowDependencyError", {
+	stepId: t.String,
+	unresolvedRef: t.String,
+	message: t.String
+}) {}, o = class extends t.TaggedError()("FlowBriefIncomplete", {
+	missing: t.Array(t.String),
+	message: t.String
+}) {}, s = class extends t.TaggedError()("FlowNotAwaitingResponse", {
+	runId: t.String,
+	status: t.String,
+	message: t.String
+}) {}, c = class extends t.TaggedError()("FlowReviewDeliveryError", {
+	runId: t.String,
+	reason: t.Literal("runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"),
+	message: t.String
+}) {}, l = class extends t.TaggedError()("FlowCapabilityMissing", {
+	capability: t.String,
+	message: t.String,
+	receipt: t.optional(e)
+}) {}, u = class extends t.TaggedError()("FlowAgentUnavailable", {
+	agentRef: t.String,
+	reason: t.Literal("not-found", "access-revoked", "model-unusable"),
+	message: t.String,
+	publicMessage: t.optional(t.String)
 }) {};
 //#endregion
-export { l as FlowAgentUnavailable, a as FlowBriefIncomplete, c as FlowCapabilityMissing, i as FlowDependencyError, o as FlowNotAwaitingResponse, t as FlowNotFound, s as FlowReviewDeliveryError, n as FlowRunNotFound, r as FlowValidationError };
+export { u as FlowAgentUnavailable, o as FlowBriefIncomplete, l as FlowCapabilityMissing, a as FlowDependencyError, s as FlowNotAwaitingResponse, n as FlowNotFound, c as FlowReviewDeliveryError, r as FlowRunNotFound, i as FlowValidationError };

package/dist/index.d.ts

@@ -293,24 +293,38 @@ export declare const buildFlowRunExecute: (ctx: AppContext, deps?: EngineDeps) =
 export declare const cadenceMatches: (cadence: FlowCadence, now: Date) => boolean;
 
 /**
- * Cancel a run on BOTH sides in one operation: the row (what the UI and the
- * cadence read) and the workflow execution (what actually runs, or waits at a
- * human step). Either half alone drifts — a row marked cancelled over a
- * suspended execution, or a cancelled execution under a row that still says
- * `waiting` — and a reader of one side never learns about the other.
+ * Request cancellation on both sides: the row prevents further cooperative
+ * steps, and the workflow facade interrupts a running or suspended execution.
+ * The row status alone is not an engine acknowledgement. Only a confirmed
+ * cancelled snapshot yields engine='cancelled'; accepted and unknown receipts
+ * retain their uncertainty, including a lost acknowledgement.
  *
- * The row is patched first, so a cooperative check between steps sees it even
- * if the engine's interrupt is slow; the execution's own interrupt handler
- * (`buildFlowRunExecute`) writes the same terminal fields again, harmlessly.
- * An execution that cannot be reached (no runtime, not started) leaves the row
- * cancelled and says so in `engine`.
+ * Already completed flows are not rewritten. The conditional row update also
+ * protects a completion committed after the initial read. Repeated requests
+ * retain the original terminal timestamps but can retry engine cancellation.
  */
 export declare const cancelFlow: (ctx: AppContext, args: {
     runId: string;
 }) => Effect.Effect<{
-    runId: string;
-    status: RunStatus;
-    engine: "unreachable" | "cancelled";
+    readonly status: "failed" | "pending" | "cancelled" | "running" | "succeeded" | "waiting";
+    readonly runId: string;
+    readonly control: {
+        readonly snapshot: {
+            readonly status: "unknown" | "failed" | "cancelled" | "running" | "succeeded" | "suspended";
+            readonly id: string;
+            readonly error?: {
+                readonly message: string;
+                readonly tag: string | null;
+            } | undefined;
+            readonly output?: unknown;
+            readonly executionId: string;
+            readonly workflowName: string;
+        };
+        readonly kind: "unknown" | "accepted" | "confirmed" | "already-terminal";
+        readonly operation: "resume" | "cancel";
+        readonly requestId: string | null;
+    } | null;
+    readonly engine: "unknown" | "unreachable" | "cancelled" | "accepted" | "already-terminal" | "not-requested";
 }, FlowRunNotFound, never>;
 
 /** Staged follow-up when `chainTo.requireConfirmation` is set. */
@@ -535,6 +549,32 @@ export declare interface FlowCadence {
     readonly defaultInput?: Json | undefined;
 }
 
+/** Row state and engine acknowledgement are separate observations. Retain the
+ * control request identity so an accepted/unknown request can be observed. */
+export declare const FlowCancelReceipt: Schema.filter<Schema.Struct<{
+    runId: typeof Schema.NonEmptyString;
+    status: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "cancelled"]>;
+    engine: Schema.Literal<["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
+    control: Schema.NullOr<Schema.filter<Schema.Struct<{
+        operation: Schema.Literal<["cancel", "resume"]>;
+        kind: Schema.Literal<["accepted", "confirmed", "unknown", "already-terminal"]>;
+        requestId: Schema.NullOr<typeof Schema.NonEmptyString>;
+        snapshot: Schema.Struct<{
+            id: typeof Schema.String;
+            workflowName: typeof Schema.String;
+            executionId: typeof Schema.String;
+            status: Schema.Union<[Schema.Literal<["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<["unknown"]>]>;
+            output: Schema.optional<typeof Schema.Unknown>;
+            error: Schema.optional<Schema.Struct<{
+                tag: Schema.NullOr<typeof Schema.String>;
+                message: typeof Schema.String;
+            }>>;
+        }>;
+    }>>>;
+}>>;
+
+export declare type FlowCancelReceipt = typeof FlowCancelReceipt.Type;
+
 /** A generation step required a capability the host did not provide (e.g. a
  *  media modality with no configured generator, or storage for the artifact). */
 declare class FlowCapabilityMissing extends FlowCapabilityMissing_base {
@@ -545,6 +585,21 @@ declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapability
 } & {
     capability: typeof Schema.String;
     message: typeof Schema.String;
+    /** A charge that happened before the failure — the generation succeeded and
+     *  was billed, then storing its artifact did not. The engine records it on
+     *  the failed step, so the run's cost is not reported as unknown when it is
+     *  merely incomplete. */
+    receipt: Schema.optional<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>>;
+        }>>;
+    }>>;
 }>;
 
 /** Follow-up flow spec. On success, map source → the child's brief. */
@@ -1190,6 +1245,26 @@ export declare interface MediaPersist {
     readonly ingestUrl?: (url: string, run: FlowRunContext) => Effect.Effect<StoredMedia, unknown, unknown>;
 }
 
+/**
+ * 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 MediaResult: Schema.Struct<{
     artifacts: Schema.filter<Schema.Array$<Schema.Struct<{
         url: typeof Schema.NonEmptyString;
@@ -1202,6 +1277,13 @@ export declare const MediaResult: Schema.Struct<{
     costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
     /** A provider/usage correlation only, never a storage reference. */
     requestId: Schema.optional<typeof Schema.NonEmptyString>;
+    /** What the generation consumed — the quantity behind `costMicroUsd`. */
+    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 MediaResult = typeof MediaResult.Type;
@@ -1384,6 +1466,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. */
@@ -1426,6 +1515,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?: {
@@ -1479,6 +1570,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;
+
 /** A persisted artifact — a hosted URL + optional storage ref id. */
 export declare interface StoredMedia {
     readonly url: string;