@voltro/plugin-ai-flows 0.74.0 → 0.76.0

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

@@ -1,11 +1,11 @@
 import { Schema as e } from "effect";
-import { WorkflowRunHandleSchema as t } from "@voltro/protocol";
+import { WorkflowControlResultSchema as t, WorkflowRunHandleSchema as n } from "@voltro/protocol";
 //#region src/condition.ts
-var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
+var r = e.Literal("truthy", "falsy", "eq", "neq", "contains"), i = e.Struct({
 	ref: e.String,
-	op: n,
+	op: r,
 	value: e.optional(e.Unknown)
-}), i = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, a = (e, t) => {
+}), a = (e) => e == null ? !1 : typeof e == "boolean" ? e : !Array.isArray(e) || e.length > 0, o = (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 {
@@ -14,21 +14,21 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		return !1;
 	}
 	return String(e) === String(t);
-}, o = (e, t) => {
+}, s = (e, t) => {
 	let n = t[e.ref];
 	switch (e.op) {
-		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 "truthy": return a(n);
+		case "falsy": return !a(n);
+		case "eq": return o(n, e.value);
+		case "neq": return !o(n, e.value);
 		case "contains": {
 			if (n == null) return !1;
-			if (Array.isArray(n)) return n.some((t) => a(t, e.value));
+			if (Array.isArray(n)) return n.some((t) => o(t, e.value));
 			let t = e.value;
 			return typeof t != "string" && typeof t != "number" ? !1 : String(n).includes(String(t));
 		}
 	}
-}, s = (e) => {
+}, c = (e) => {
 	switch (e.op) {
 		case "truthy": return `{{${e.ref}}} is set`;
 		case "falsy": return `{{${e.ref}}} is not set`;
@@ -36,14 +36,30 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 		case "neq": return `{{${e.ref}}} does not equal ${JSON.stringify(e.value)}`;
 		case "contains": return `{{${e.ref}}} contains ${JSON.stringify(e.value)}`;
 	}
-}, c = e.Struct({
+}, l = 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({
+	admission: n
+}), u = e.Literal("deterministic", "agentic"), d = e.Literal("draft", "active", "archived"), f = e.Literal("private", "organization", "shared"), p = e.Literal("pending", "running", "waiting", "succeeded", "failed", "cancelled"), m = e.Struct({
+	runId: e.NonEmptyString,
+	status: p,
+	engine: e.Literal("cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"),
+	control: e.NullOr(t)
+}).pipe(e.filter((e) => {
+	let t = e.control;
+	if (t !== null && t.operation !== "cancel") return !1;
+	switch (e.engine) {
+		case "cancelled": return t !== null && t.snapshot.status === "cancelled" && (t.kind === "confirmed" || t.kind === "already-terminal");
+		case "accepted": return t?.kind === "accepted";
+		case "already-terminal": return t?.kind === "already-terminal" && t.snapshot.status !== "cancelled";
+		case "unknown": return t === null || t.kind === "unknown";
+		case "unreachable":
+		case "not-requested": return t === null;
+	}
+}, { message: () => "Flow cancellation acknowledgement contradicts its workflow control receipt" })), h = e.Literal("manual", "cron"), g = e.Literal("agent", "generate", "structured", "note", "human"), _ = e.Literal("text", "image", "video", "audio"), v = e.Literal("approve", "choice", "text"), y = e.Struct({
 	value: e.String,
 	label: e.String
-}), v = e.Union(e.Struct({
+}), b = e.Union(e.Struct({
 	from: e.Literal("upload"),
 	url: e.String,
 	mediaType: e.optional(e.NonEmptyString)
@@ -51,50 +67,50 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = e.Struct({
 	from: e.Literal("step"),
 	ref: e.String,
 	artifact: e.optional(e.Int.pipe(e.nonNegative()))
-})), y = e.Record({
+})), x = e.Record({
 	key: e.String,
-	value: v
-}), b = e.Record({
+	value: b
+}), S = e.Record({
 	key: e.String,
 	value: e.Unknown
-}), x = e.Struct({
+}), C = 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({
+}), w = e.Array(C).pipe(e.filter((e) => e.filter((e) => e.role === "primary").length === 1)), T = e.Struct({
 	id: e.String,
 	title: e.optional(e.String),
 	description: e.optional(e.String),
-	type: m,
+	type: g,
 	outputKey: e.optional(e.String),
 	prompt: e.optional(e.String),
-	modality: e.optional(h),
+	modality: e.optional(_),
 	model: e.optional(e.String),
-	params: e.optional(b),
-	mediaInputs: e.optional(y),
+	params: e.optional(S),
+	mediaInputs: e.optional(x),
 	agentRef: e.optional(e.String),
-	schema: e.optional(b),
-	reviewMode: e.optional(g),
-	options: e.optional(e.Array(_)),
-	when: e.optional(r),
+	schema: e.optional(S),
+	reviewMode: e.optional(v),
+	options: e.optional(e.Array(y)),
+	when: e.optional(i),
 	group: e.optional(e.String),
 	timeoutMs: e.optional(e.Number)
-}), w = e.Struct({
+}), E = 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)
-}), T = e.Struct({
+}), D = e.Struct({
 	flowRef: e.String,
 	mappings: e.Array(e.Struct({
 		targetKey: e.String,
 		sourceKey: e.String
 	})),
 	requireConfirmation: e.optional(e.Boolean)
-}), E = e.Struct({
+}), O = e.Struct({
 	frequency: e.optional(e.Literal("weekly", "monthly")),
 	repeats: e.Array(e.Number),
 	intervalWeeks: e.optional(e.Number),
@@ -102,51 +118,62 @@ var n = e.Literal("truthy", "falsy", "eq", "neq", "contains"), r = 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(b)
-}), D = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), O = e.Struct({
-	mode: g,
-	options: e.optional(e.Array(_)),
+	defaultInput: e.optional(S)
+}), k = e.Literal("pending", "running", "waiting", "succeeded", "failed", "skipped"), A = e.Struct({
+	mode: v,
+	options: e.optional(e.Array(y)),
 	prompt: e.String
-}), k = e.Literal("gateway", "estimated", "unpriced"), A = e.Literal("actual", "estimated", "incomplete", "unknown"), j = e.Struct({
+}), j = e.Literal("gateway", "estimated", "unpriced"), M = e.Literal("actual", "estimated", "incomplete", "unknown"), N = 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()))
+}), P = e.Struct({
+	costMicroUsd: e.optional(e.Finite.pipe(e.nonNegative())),
+	costSource: e.optional(j),
+	requestId: e.optional(e.NonEmptyString),
+	usage: e.optional(N)
+}), F = e.Struct({
 	id: e.Number,
 	title: e.String,
 	description: e.optional(e.String),
-	type: m,
-	status: D,
+	type: g,
+	status: k,
 	startedAt: e.optional(e.String),
 	completedAt: e.optional(e.String),
 	costMicroUsd: e.optional(e.Number),
-	costSource: e.optional(k),
+	costSource: e.optional(j),
 	requestId: e.optional(e.String),
+	usage: e.optional(N),
 	url: e.optional(e.String),
-	artifacts: e.optional(S),
+	artifacts: e.optional(w),
 	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({
+	review: e.optional(A)
+}), I = 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({
+}), L = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
-	response: M
-}), P = e.Struct({
+	response: I
+}), R = e.Struct({
 	runId: e.NonEmptyString,
 	stepIndex: e.Int.pipe(e.nonNegative()),
 	executionId: e.NonEmptyString,
 	eventId: e.NonEmptyString,
 	status: e.Literal("accepted")
-}), F = e.Struct({
+}), z = e.Struct({
 	flowRef: e.String,
-	input: b,
+	input: S,
 	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) => {
+}), B = 30, V = 1, H = 100, U = (e) => e == null || !Number.isFinite(e) ? 30 : Math.min(100, Math.max(1, Math.trunc(e))), W = (e) => e.replace(/[^\w.-]/g, "_"), G = (e) => {
 	let t = (e.steps ?? []).map((e) => e.outputKey ? {
 		...e,
-		outputKey: B(e.outputKey)
+		outputKey: W(e.outputKey)
 	} : e), n = e.orchestratorModel || e.orchestratorInstructions ? {
 		...e.orchestratorModel ? { model: e.orchestratorModel } : {},
 		...e.orchestratorInstructions ? { instructions: e.orchestratorInstructions } : {}
@@ -155,7 +182,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: U(e.maxSteps),
 		brief: e.brief ?? [],
 		...n ? { orchestrator: n } : {},
 		...e.chain ? { chain: e.chain } : {},
@@ -164,4 +191,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 { F as A, c as B, P as C, A as D, y as E, U as F, a as H, G as I, W as L, g as M, N, h as O, f as P, r as R, x as S, v as T, s as V, H as _, O as a, w as b, u as c, l as d, d as f, B as g, S as h, j as i, k as j, p as k, L as l, I as m, z as n, m as o, T as p, M as r, D as s, E as t, R as u, V as v, _ as w, b as x, C as y, i as z };

package/dist/ir.d.ts

@@ -105,6 +105,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;
+
 /** Follow-up flow spec. On success, map source → the child's brief. */
 export declare const FlowChain: Schema.Struct<{
     /** Child flow id (data) or name (code). */
@@ -412,6 +438,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 +519,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 +568,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 +611,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, H as o, I as s, L as c, M as l, N as u, O as d, P as f, R as p, S as m, T as h, V as g, _, a as v, b as y, c as b, d as x, f as S, g as C, h as w, i as T, j as E, k as D, l as O, m as k, n as A, o as j, p as M, r as N, s as P, t as F, u as I, v as L, w as R, x as z, y as B, z as V } from "./ir-BW5JRUiH.js";
+export { F as BriefField, A as ChainPending, p as ConditionOp, N as CostCompleteness, T as CostSource, v as FlowCadence, j as FlowCancelReceipt, P as FlowChain, b as FlowMode, O as FlowReviewInput, I as FlowReviewReceipt, x as FlowStartReceipt, S as FlowStatus, M as FlowStep, k as HumanResponse, w as Json, C as MAX_STEPS_DEFAULT, _ as MAX_STEPS_MAX, L as MAX_STEPS_MIN, B as MediaArtifact, y as MediaArtifacts, z as MediaInputSlot, m as MediaInputs, n as MediaReceipt, R as Modality, h as ReviewMode, i as ReviewOption, r as RunReview, d as RunSource, D as RunStatus, e as RunStep, E as RunStepStatus, V as StepCondition, l as StepType, u as StepUsage, f as Visibility, a as clampMaxSteps, t as describeCondition, g as evaluateCondition, o as isTruthy, s as normalizeFlow, c 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.74.0",
+  "version": "0.76.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,19 +58,19 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/ai": "0.74.0",
-    "@voltro/client": "0.74.0",
-    "@voltro/database": "0.74.0",
-    "@voltro/env": "0.74.0",
-    "@voltro/plugin-audit": "0.74.0",
-    "@voltro/plugin-multitenancy": "0.74.0",
-    "@voltro/plugin-soft-delete": "0.74.0",
-    "@voltro/protocol": "0.74.0",
-    "@voltro/runtime": "0.74.0",
-    "@voltro/workflow": "0.74.0"
+    "@voltro/ai": "0.76.0",
+    "@voltro/client": "0.76.0",
+    "@voltro/database": "0.76.0",
+    "@voltro/env": "0.76.0",
+    "@voltro/plugin-audit": "0.76.0",
+    "@voltro/plugin-multitenancy": "0.76.0",
+    "@voltro/plugin-soft-delete": "0.76.0",
+    "@voltro/protocol": "0.76.0",
+    "@voltro/runtime": "0.76.0",
+    "@voltro/workflow": "0.76.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.1"
+    "effect": "^3.22.2"
   },
   "publishConfig": {
     "access": "public"