jev-recipes 0.0.4 → 0.2.0

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

@@ -0,0 +1,664 @@
+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>;
+        }>;
+    };
+};