@voltro/plugin-ai-flows 0.84.0 → 0.85.0

package/dist/errors.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 /**
  * An agent the host will not serve for this run: access revoked, a model it
@@ -9,52 +10,46 @@ import { Schema } from 'effect';
 export declare class FlowAgentUnavailable extends FlowAgentUnavailable_base {
 }
 
-declare const FlowAgentUnavailable_base: Schema.TaggedErrorClass<FlowAgentUnavailable, "FlowAgentUnavailable", {
-    readonly _tag: Schema.tag<"FlowAgentUnavailable">;
-} & {
-    agentRef: typeof Schema.String;
-    reason: Schema.Literal<["not-found", "access-revoked", "model-unusable"]>;
-    message: typeof Schema.String;
-    publicMessage: Schema.optional<typeof Schema.String>;
-}>;
+declare const FlowAgentUnavailable_base: Schema.Class<FlowAgentUnavailable, Schema.TaggedStruct<"FlowAgentUnavailable", {
+    readonly agentRef: Schema.String;
+    readonly reason: Schema.Literals<readonly ["not-found", "access-revoked", "model-unusable"]>;
+    readonly message: Schema.String;
+    readonly publicMessage: Schema.optional<Schema.String>;
+}>, YieldableError>;
 
 /** A required brief field was blank at launch. */
 export declare class FlowBriefIncomplete extends FlowBriefIncomplete_base {
 }
 
-declare const FlowBriefIncomplete_base: Schema.TaggedErrorClass<FlowBriefIncomplete, "FlowBriefIncomplete", {
-    readonly _tag: Schema.tag<"FlowBriefIncomplete">;
-} & {
-    missing: Schema.Array$<typeof Schema.String>;
-    message: typeof Schema.String;
-}>;
+declare const FlowBriefIncomplete_base: Schema.Class<FlowBriefIncomplete, Schema.TaggedStruct<"FlowBriefIncomplete", {
+    readonly missing: Schema.$Array<Schema.String>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** 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). */
 export declare class FlowCapabilityMissing extends FlowCapabilityMissing_base {
 }
 
-declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapabilityMissing, "FlowCapabilityMissing", {
-    readonly _tag: Schema.tag<"FlowCapabilityMissing">;
-} & {
-    capability: typeof Schema.String;
-    message: typeof Schema.String;
+declare const FlowCapabilityMissing_base: Schema.Class<FlowCapabilityMissing, Schema.TaggedStruct<"FlowCapabilityMissing", {
+    readonly capability: Schema.String;
+    readonly message: 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>>;
+    readonly receipt: Schema.optional<Schema.Struct<{
+        readonly costMicroUsd: Schema.optional<Schema.Finite>;
+        readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
+        readonly requestId: Schema.optional<Schema.NonEmptyString>;
+        readonly usage: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+            readonly input: Schema.optional<Schema.Finite>;
+            readonly output: Schema.optional<Schema.Finite>;
         }>>;
     }>>;
-}>;
+}>, YieldableError>;
 
 /** A step's input still contains an unresolved `{{ref}}` (its producing step
  *  failed / was skipped). The engine aborts rather than generate on placeholder
@@ -62,72 +57,60 @@ declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapability
 export declare class FlowDependencyError extends FlowDependencyError_base {
 }
 
-declare const FlowDependencyError_base: Schema.TaggedErrorClass<FlowDependencyError, "FlowDependencyError", {
-    readonly _tag: Schema.tag<"FlowDependencyError">;
-} & {
-    stepId: typeof Schema.String;
-    unresolvedRef: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowDependencyError_base: Schema.Class<FlowDependencyError, Schema.TaggedStruct<"FlowDependencyError", {
+    readonly stepId: Schema.String;
+    readonly unresolvedRef: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** A run cannot accept a human response in its current state (not `waiting`,
  *  already answered, or cancelled). */
 export declare class FlowNotAwaitingResponse extends FlowNotAwaitingResponse_base {
 }
 
-declare const FlowNotAwaitingResponse_base: Schema.TaggedErrorClass<FlowNotAwaitingResponse, "FlowNotAwaitingResponse", {
-    readonly _tag: Schema.tag<"FlowNotAwaitingResponse">;
-} & {
-    runId: typeof Schema.String;
-    status: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowNotAwaitingResponse_base: Schema.Class<FlowNotAwaitingResponse, Schema.TaggedStruct<"FlowNotAwaitingResponse", {
+    readonly runId: Schema.String;
+    readonly status: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** A flow (definition) could not be resolved by ref (code name or row id). */
 export declare class FlowNotFound extends FlowNotFound_base {
 }
 
-declare const FlowNotFound_base: Schema.TaggedErrorClass<FlowNotFound, "FlowNotFound", {
-    readonly _tag: Schema.tag<"FlowNotFound">;
-} & {
-    flowRef: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowNotFound_base: Schema.Class<FlowNotFound, Schema.TaggedStruct<"FlowNotFound", {
+    readonly flowRef: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** No review-delivery confirmation. Unknown delivery may already have been consumed. */
 export declare class FlowReviewDeliveryError extends FlowReviewDeliveryError_base {
 }
 
-declare const FlowReviewDeliveryError_base: Schema.TaggedErrorClass<FlowReviewDeliveryError, "FlowReviewDeliveryError", {
-    readonly _tag: Schema.tag<"FlowReviewDeliveryError">;
-} & {
-    runId: typeof Schema.String;
-    reason: Schema.Literal<["runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"]>;
-    message: typeof Schema.String;
-}>;
+declare const FlowReviewDeliveryError_base: Schema.Class<FlowReviewDeliveryError, Schema.TaggedStruct<"FlowReviewDeliveryError", {
+    readonly runId: Schema.String;
+    readonly reason: Schema.Literals<readonly ["runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** A flow run row could not be found. */
 export declare class FlowRunNotFound extends FlowRunNotFound_base {
 }
 
-declare const FlowRunNotFound_base: Schema.TaggedErrorClass<FlowRunNotFound, "FlowRunNotFound", {
-    readonly _tag: Schema.tag<"FlowRunNotFound">;
-} & {
-    runId: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowRunNotFound_base: Schema.Class<FlowRunNotFound, Schema.TaggedStruct<"FlowRunNotFound", {
+    readonly runId: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** The flow definition is invalid (bad step graph, unknown agent, cycle, …). */
 export declare class FlowValidationError extends FlowValidationError_base {
 }
 
-declare const FlowValidationError_base: Schema.TaggedErrorClass<FlowValidationError, "FlowValidationError", {
-    readonly _tag: Schema.tag<"FlowValidationError">;
-} & {
-    flowRef: typeof Schema.String;
-    message: typeof Schema.String;
+declare const FlowValidationError_base: Schema.Class<FlowValidationError, Schema.TaggedStruct<"FlowValidationError", {
+    readonly flowRef: Schema.String;
+    readonly message: Schema.String;
     /** Optional per-issue detail for the editor. */
-    issues: Schema.optional<Schema.Array$<typeof Schema.String>>;
-}>;
+    readonly issues: Schema.optional<Schema.$Array<Schema.String>>;
+}>, YieldableError>;
 
 export { }

package/dist/errors.js

@@ -1,4 +1,4 @@
-import { C as e } from "./ir-CdDUTf98.js";
+import { C as e } from "./ir-Cjk1kQl9.js";
 import { Schema as t } from "effect";
 //#region src/errors.ts
 var n = class extends t.TaggedError()("FlowNotFound", {
@@ -24,7 +24,12 @@ var n = class extends t.TaggedError()("FlowNotFound", {
 	message: t.String
 }) {}, c = class extends t.TaggedError()("FlowReviewDeliveryError", {
 	runId: t.String,
-	reason: t.Literal("runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"),
+	reason: t.Literals([
+		"runtime-unavailable",
+		"invalid-run",
+		"invalid-response",
+		"delivery-unknown"
+	]),
 	message: t.String
 }) {}, l = class extends t.TaggedError()("FlowCapabilityMissing", {
 	capability: t.String,
@@ -32,7 +37,11 @@ var n = class extends t.TaggedError()("FlowNotFound", {
 	receipt: t.optional(e)
 }) {}, u = class extends t.TaggedError()("FlowAgentUnavailable", {
 	agentRef: t.String,
-	reason: t.Literal("not-found", "access-revoked", "model-unusable"),
+	reason: t.Literals([
+		"not-found",
+		"access-revoked",
+		"model-unusable"
+	]),
 	message: t.String,
 	publicMessage: t.optional(t.String)
 }) {};