jev-recipes 0.0.4 → 0.2.0

package/dist/catalog/groups/workflow.d.ts

@@ -0,0 +1,623 @@
+import type { RecipeOptions } from '../../src/schema.js';
+export declare const workflowRecipes: {
+    route: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            routes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            route: import("zod").ZodNullable<import("zod").ZodString>;
+            suggestedRoute: import("zod").ZodNullable<import("zod").ZodString>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            route: string | null;
+            suggestedRoute: string | null;
+            confidence: number;
+            probabilities: Record<string, number>;
+        }>;
+    };
+    handoff: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            rules: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                description: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            decision: import("zod").ZodEnum<{
+                review: "review";
+                human: "human";
+                continue: "continue";
+            }>;
+            matchedRules: import("zod").ZodArray<import("zod").ZodString>;
+            uncertainRules: import("zod").ZodArray<import("zod").ZodString>;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    matches: "matches";
+                    does_not_match: "does_not_match";
+                    unclear: "unclear";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    matches: "matches";
+                    does_not_match: "does_not_match";
+                    unclear: "unclear";
+                }>, import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            decision: "review" | "human" | "continue";
+            matchedRules: string[];
+            uncertainRules: string[];
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "matches" | "does_not_match" | "unclear";
+                confidence: number;
+                probabilities: Record<"matches" | "does_not_match" | "unclear", number>;
+            }[];
+        }>;
+    };
+    'tool-fit': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            task: import("zod").ZodString;
+            tool: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                fits: "fits";
+                does_not_fit: "does_not_fit";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                fits: "fits";
+                does_not_fit: "does_not_fit";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "fits" | "does_not_fit";
+            confidence: number;
+            probabilities: Record<"unclear" | "fits" | "does_not_fit", number>;
+        }>;
+    };
+    'argument-fit': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            argument: import("zod").ZodString;
+            proposedValue: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                fits: "fits";
+                conflicts: "conflicts";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                fits: "fits";
+                conflicts: "conflicts";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "fits" | "conflicts";
+            confidence: number;
+            probabilities: Record<"unclear" | "fits" | "conflicts", number>;
+        }>;
+    };
+    'result-usefulness': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            task: import("zod").ZodString;
+            result: import("zod").ZodString;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                irrelevant: "irrelevant";
+                useful: "useful";
+                no_useful_information: "no_useful_information";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                irrelevant: "irrelevant";
+                useful: "useful";
+                no_useful_information: "no_useful_information";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "irrelevant" | "useful" | "no_useful_information";
+            confidence: number;
+            probabilities: Record<"unclear" | "irrelevant" | "useful" | "no_useful_information", number>;
+        }>;
+    };
+    'result-outcome': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            task: import("zod").ZodString;
+            result: import("zod").ZodString;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                success: "success";
+                unclear: "unclear";
+                partial_success: "partial_success";
+                failure: "failure";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                success: "success";
+                unclear: "unclear";
+                partial_success: "partial_success";
+                failure: "failure";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "success" | "unclear" | "partial_success" | "failure";
+            confidence: number;
+            probabilities: Record<"success" | "unclear" | "partial_success" | "failure", number>;
+        }>;
+    };
+    'action-scope': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            proposedAction: import("zod").ZodString;
+            constraints: import("zod").ZodOptional<import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                within_scope: "within_scope";
+                additional_work: "additional_work";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                within_scope: "within_scope";
+                additional_work: "additional_work";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "within_scope" | "additional_work";
+            confidence: number;
+            probabilities: Record<"unclear" | "within_scope" | "additional_work", number>;
+        }>;
+    };
+    'step-progress': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            objective: import("zod").ZodString;
+            previousState: import("zod").ZodString;
+            observation: import("zod").ZodString;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                progress: "progress";
+                no_progress: "no_progress";
+                setback: "setback";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                progress: "progress";
+                no_progress: "no_progress";
+                setback: "setback";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "progress" | "no_progress" | "setback";
+            confidence: number;
+            probabilities: Record<"unclear" | "progress" | "no_progress" | "setback", number>;
+        }>;
+    };
+    'repeated-attempt': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            objective: import("zod").ZodString;
+            previousAttempt: import("zod").ZodString;
+            proposedAttempt: import("zod").ZodString;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                same_approach: "same_approach";
+                different_approach: "different_approach";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                same_approach: "same_approach";
+                different_approach: "different_approach";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "same_approach" | "different_approach";
+            confidence: number;
+            probabilities: Record<"unclear" | "same_approach" | "different_approach", number>;
+        }>;
+    };
+    'step-complete': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            condition: import("zod").ZodString;
+            evidence: import("zod").ZodString;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                met: "met";
+                unmet: "unmet";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                met: "met";
+                unmet: "unmet";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "met" | "unmet";
+            confidence: number;
+            probabilities: Record<"unclear" | "met" | "unmet", number>;
+        }>;
+    };
+    'failure-kind': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            failure: import("zod").ZodString;
+            categories: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                matched: "matched";
+                none: "none";
+                ambiguous: "ambiguous";
+            }>;
+            selection: import("zod").ZodNullable<import("zod").ZodString>;
+            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodObject<{
+                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+                none: import("zod").ZodNumber;
+                ambiguous: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "matched" | "none" | "ambiguous";
+            selection: string | null;
+            suggestedSelection: string | null;
+            confidence: number;
+            probabilities: {
+                candidates: Record<string, number>;
+                none: number;
+                ambiguous: number;
+            };
+        }>;
+    };
+    'instruction-fit': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            instruction: import("zod").ZodString;
+            task: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                applies: "applies";
+                does_not_apply: "does_not_apply";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                applies: "applies";
+                does_not_apply: "does_not_apply";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "unclear" | "applies" | "does_not_apply";
+            confidence: number;
+            probabilities: Record<"unclear" | "applies" | "does_not_apply", number>;
+        }>;
+    };
+};