jev-recipes 0.2.0 → 0.3.0

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

@@ -1,664 +0,0 @@
-import type { RecipeOptions } from '../../src/schema.js';
-export declare const retrievalRecipes: {
-    rerank: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            query: import("zod").ZodString;
-            items: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            topK: import("zod").ZodOptional<import("zod").ZodNumber>;
-            minRelevance: 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";
-            }>;
-            items: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-                relevance: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            evaluated: 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";
-            items: {
-                id: string;
-                text: string;
-                relevance: number;
-            }[];
-            evaluated: number;
-        }>;
-    };
-    verify: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            claims: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                claim: import("zod").ZodString;
-                evidence: 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>;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-            allSupported: import("zod").ZodBoolean;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "supported" | "contradicted" | "unsupported";
-                confidence: number;
-                probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
-            }[];
-            allSupported: boolean;
-        }>;
-    };
-    answerability: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            evidence: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: 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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>;
-            canAnswer: import("zod").ZodBoolean;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>, 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: "sufficient" | "partial" | "insufficient" | "conflicting";
-            canAnswer: boolean;
-            confidence: number;
-            probabilities: Record<"sufficient" | "partial" | "insufficient" | "conflicting", number>;
-        }>;
-    };
-    'retrieval-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            context: 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";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>, 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" | "needed" | "unnecessary";
-            confidence: number;
-            probabilities: Record<"unclear" | "needed" | "unnecessary", number>;
-        }>;
-    };
-    'freshness-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: 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";
-                current: "current";
-                stable: "stable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                current: "current";
-                stable: "stable";
-            }>, 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" | "current" | "stable";
-            confidence: number;
-            probabilities: Record<"unclear" | "current" | "stable", number>;
-        }>;
-    };
-    'source-applicability': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            passage: import("zod").ZodString;
-            scenario: 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>;
-        }>;
-    };
-    'evidence-conflict': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstPassage: import("zod").ZodString;
-            secondPassage: import("zod").ZodString;
-            question: 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<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                compatible: "compatible";
-                different_scope: "different_scope";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                compatible: "compatible";
-                different_scope: "different_scope";
-            }>, 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: "conflicting" | "unclear" | "compatible" | "different_scope";
-            confidence: number;
-            probabilities: Record<"conflicting" | "unclear" | "compatible" | "different_scope", number>;
-        }>;
-    };
-    'passage-duplicate': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstPassage: import("zod").ZodString;
-            secondPassage: 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";
-                duplicate: "duplicate";
-                overlapping: "overlapping";
-                distinct: "distinct";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                duplicate: "duplicate";
-                overlapping: "overlapping";
-                distinct: "distinct";
-            }>, 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" | "duplicate" | "overlapping" | "distinct";
-            confidence: number;
-            probabilities: Record<"unclear" | "duplicate" | "overlapping" | "distinct", number>;
-        }>;
-    };
-    'evidence-novelty': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            passage: import("zod").ZodString;
-            existingEvidence: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            question: 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";
-                adds_information: "adds_information";
-                repeats_information: "repeats_information";
-                irrelevant: "irrelevant";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                adds_information: "adds_information";
-                repeats_information: "repeats_information";
-                irrelevant: "irrelevant";
-            }>, 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" | "adds_information" | "repeats_information" | "irrelevant";
-            confidence: number;
-            probabilities: Record<"unclear" | "adds_information" | "repeats_information" | "irrelevant", number>;
-        }>;
-    };
-    'cache-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            originalQuestion: import("zod").ZodString;
-            cachedAnswer: 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";
-                reusable: "reusable";
-                unsuitable: "unsuitable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                reusable: "reusable";
-                unsuitable: "unsuitable";
-            }>, 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" | "reusable" | "unsuitable";
-            confidence: number;
-            probabilities: Record<"unclear" | "reusable" | "unsuitable", number>;
-        }>;
-    };
-    'query-equivalence': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstQuestion: import("zod").ZodString;
-            secondQuestion: 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";
-                equivalent: "equivalent";
-                related: "related";
-                different: "different";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                equivalent: "equivalent";
-                related: "related";
-                different: "different";
-            }>, 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" | "equivalent" | "related" | "different";
-            confidence: number;
-            probabilities: Record<"unclear" | "equivalent" | "related" | "different", number>;
-        }>;
-    };
-    'context-role': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            passage: 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";
-                unrelated: "unrelated";
-                direct_evidence: "direct_evidence";
-                background: "background";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                direct_evidence: "direct_evidence";
-                background: "background";
-            }>, 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" | "unrelated" | "direct_evidence" | "background";
-            confidence: number;
-            probabilities: Record<"unclear" | "unrelated" | "direct_evidence" | "background", number>;
-        }>;
-    };
-    'query-specificity': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: 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<{
-                ambiguous: "ambiguous";
-                specific: "specific";
-                too_broad: "too_broad";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                ambiguous: "ambiguous";
-                specific: "specific";
-                too_broad: "too_broad";
-            }>, 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: "ambiguous" | "specific" | "too_broad";
-            confidence: number;
-            probabilities: Record<"ambiguous" | "specific" | "too_broad", number>;
-        }>;
-    };
-};