jev-recipes 0.2.0 → 0.4.0

package/dist/catalog/groups/retrieval.js

@@ -1,106 +0,0 @@
-import { rerank, rerankInputSchema, rerankResultSchema } from '../../recipes/rerank/index.js';
-import { metadata as rerankMetadata } from '../../recipes/rerank/metadata.js';
-import { verify, verifyInputSchema, verifyResultSchema } from '../../recipes/verify/index.js';
-import { metadata as verifyMetadata } from '../../recipes/verify/metadata.js';
-import { answerability, answerabilityInputSchema, answerabilityResultSchema, } from '../../recipes/answerability/index.js';
-import { metadata as answerabilityMetadata } from '../../recipes/answerability/metadata.js';
-import { retrievalNeeded, retrievalNeededInputSchema, retrievalNeededResultSchema, } from '../../recipes/retrieval-needed/index.js';
-import { metadata as retrievalNeededMetadata } from '../../recipes/retrieval-needed/metadata.js';
-import { freshnessNeeded, freshnessNeededInputSchema, freshnessNeededResultSchema, } from '../../recipes/freshness-needed/index.js';
-import { metadata as freshnessNeededMetadata } from '../../recipes/freshness-needed/metadata.js';
-import { sourceApplicability, sourceApplicabilityInputSchema, sourceApplicabilityResultSchema, } from '../../recipes/source-applicability/index.js';
-import { metadata as sourceApplicabilityMetadata } from '../../recipes/source-applicability/metadata.js';
-import { evidenceConflict, evidenceConflictInputSchema, evidenceConflictResultSchema, } from '../../recipes/evidence-conflict/index.js';
-import { metadata as evidenceConflictMetadata } from '../../recipes/evidence-conflict/metadata.js';
-import { passageDuplicate, passageDuplicateInputSchema, passageDuplicateResultSchema, } from '../../recipes/passage-duplicate/index.js';
-import { metadata as passageDuplicateMetadata } from '../../recipes/passage-duplicate/metadata.js';
-import { evidenceNovelty, evidenceNoveltyInputSchema, evidenceNoveltyResultSchema, } from '../../recipes/evidence-novelty/index.js';
-import { metadata as evidenceNoveltyMetadata } from '../../recipes/evidence-novelty/metadata.js';
-import { cacheMatch, cacheMatchInputSchema, cacheMatchResultSchema, } from '../../recipes/cache-match/index.js';
-import { metadata as cacheMatchMetadata } from '../../recipes/cache-match/metadata.js';
-import { queryEquivalence, queryEquivalenceInputSchema, queryEquivalenceResultSchema, } from '../../recipes/query-equivalence/index.js';
-import { metadata as queryEquivalenceMetadata } from '../../recipes/query-equivalence/metadata.js';
-import { contextRole, contextRoleInputSchema, contextRoleResultSchema, } from '../../recipes/context-role/index.js';
-import { metadata as contextRoleMetadata } from '../../recipes/context-role/metadata.js';
-import { querySpecificity, querySpecificityInputSchema, querySpecificityResultSchema, } from '../../recipes/query-specificity/index.js';
-import { metadata as querySpecificityMetadata } from '../../recipes/query-specificity/metadata.js';
-export const retrievalRecipes = {
-    rerank: {
-        metadata: rerankMetadata,
-        inputSchema: rerankInputSchema,
-        resultSchema: rerankResultSchema,
-        run: (input, options) => rerank(rerankInputSchema.parse(input), options),
-    },
-    verify: {
-        metadata: verifyMetadata,
-        inputSchema: verifyInputSchema,
-        resultSchema: verifyResultSchema,
-        run: (input, options) => verify(verifyInputSchema.parse(input), options),
-    },
-    answerability: {
-        metadata: answerabilityMetadata,
-        inputSchema: answerabilityInputSchema,
-        resultSchema: answerabilityResultSchema,
-        run: (input, options) => answerability(answerabilityInputSchema.parse(input), options),
-    },
-    'retrieval-needed': {
-        metadata: retrievalNeededMetadata,
-        inputSchema: retrievalNeededInputSchema,
-        resultSchema: retrievalNeededResultSchema,
-        run: (input, options) => retrievalNeeded(retrievalNeededInputSchema.parse(input), options),
-    },
-    'freshness-needed': {
-        metadata: freshnessNeededMetadata,
-        inputSchema: freshnessNeededInputSchema,
-        resultSchema: freshnessNeededResultSchema,
-        run: (input, options) => freshnessNeeded(freshnessNeededInputSchema.parse(input), options),
-    },
-    'source-applicability': {
-        metadata: sourceApplicabilityMetadata,
-        inputSchema: sourceApplicabilityInputSchema,
-        resultSchema: sourceApplicabilityResultSchema,
-        run: (input, options) => sourceApplicability(sourceApplicabilityInputSchema.parse(input), options),
-    },
-    'evidence-conflict': {
-        metadata: evidenceConflictMetadata,
-        inputSchema: evidenceConflictInputSchema,
-        resultSchema: evidenceConflictResultSchema,
-        run: (input, options) => evidenceConflict(evidenceConflictInputSchema.parse(input), options),
-    },
-    'passage-duplicate': {
-        metadata: passageDuplicateMetadata,
-        inputSchema: passageDuplicateInputSchema,
-        resultSchema: passageDuplicateResultSchema,
-        run: (input, options) => passageDuplicate(passageDuplicateInputSchema.parse(input), options),
-    },
-    'evidence-novelty': {
-        metadata: evidenceNoveltyMetadata,
-        inputSchema: evidenceNoveltyInputSchema,
-        resultSchema: evidenceNoveltyResultSchema,
-        run: (input, options) => evidenceNovelty(evidenceNoveltyInputSchema.parse(input), options),
-    },
-    'cache-match': {
-        metadata: cacheMatchMetadata,
-        inputSchema: cacheMatchInputSchema,
-        resultSchema: cacheMatchResultSchema,
-        run: (input, options) => cacheMatch(cacheMatchInputSchema.parse(input), options),
-    },
-    'query-equivalence': {
-        metadata: queryEquivalenceMetadata,
-        inputSchema: queryEquivalenceInputSchema,
-        resultSchema: queryEquivalenceResultSchema,
-        run: (input, options) => queryEquivalence(queryEquivalenceInputSchema.parse(input), options),
-    },
-    'context-role': {
-        metadata: contextRoleMetadata,
-        inputSchema: contextRoleInputSchema,
-        resultSchema: contextRoleResultSchema,
-        run: (input, options) => contextRole(contextRoleInputSchema.parse(input), options),
-    },
-    'query-specificity': {
-        metadata: querySpecificityMetadata,
-        inputSchema: querySpecificityInputSchema,
-        resultSchema: querySpecificityResultSchema,
-        run: (input, options) => querySpecificity(querySpecificityInputSchema.parse(input), options),
-    },
-};

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

@@ -1,522 +0,0 @@
-import type { RecipeOptions } from '../../src/schema.js';
-export declare const supportRecipes: {
-    'issue-impact': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: 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";
-                blocked: "blocked";
-                degraded: "degraded";
-                cosmetic: "cosmetic";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                blocked: "blocked";
-                degraded: "degraded";
-                cosmetic: "cosmetic";
-            }>, 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" | "blocked" | "degraded" | "cosmetic";
-            confidence: number;
-            probabilities: Record<"unclear" | "blocked" | "degraded" | "cosmetic", number>;
-        }>;
-    };
-    'attempted-step': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            step: import("zod").ZodString;
-            conversation: 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";
-                tried: "tried";
-                not_tried: "not_tried";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                tried: "tried";
-                not_tried: "not_tried";
-            }>, 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" | "tried" | "not_tried";
-            confidence: number;
-            probabilities: Record<"unclear" | "tried" | "not_tried", number>;
-        }>;
-    };
-    'workaround-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            issue: import("zod").ZodString;
-            workaround: import("zod").ZodString;
-            constraints: 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>;
-        }>;
-    };
-    'ticket-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstTicket: import("zod").ZodString;
-            secondTicket: 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";
-                related: "related";
-                different: "different";
-                same_issue: "same_issue";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                related: "related";
-                different: "different";
-                same_issue: "same_issue";
-            }>, 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" | "related" | "different" | "same_issue";
-            confidence: number;
-            probabilities: Record<"unclear" | "related" | "different" | "same_issue", number>;
-        }>;
-    };
-    'incident-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            ticket: import("zod").ZodString;
-            incidents: 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;
-            };
-        }>;
-    };
-    'troubleshooting-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            symptoms: import("zod").ZodString;
-            procedure: 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";
-                unsuitable: "unsuitable";
-                applicable: "applicable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unsuitable: "unsuitable";
-                applicable: "applicable";
-            }>, 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" | "unsuitable" | "applicable";
-            confidence: number;
-            probabilities: Record<"unclear" | "unsuitable" | "applicable", number>;
-        }>;
-    };
-    'frustration-signal': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: 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";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>, 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" | "expressed" | "not_expressed";
-            confidence: number;
-            probabilities: Record<"unclear" | "expressed" | "not_expressed", number>;
-        }>;
-    };
-    'urgency-signal': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: 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";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>, 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" | "expressed" | "not_expressed";
-            confidence: number;
-            probabilities: Record<"unclear" | "expressed" | "not_expressed", number>;
-        }>;
-    };
-    'feedback-kind': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: 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<{
-                question: "question";
-                unclear: "unclear";
-                other: "other";
-                bug_report: "bug_report";
-                feature_request: "feature_request";
-                praise: "praise";
-                complaint: "complaint";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                question: "question";
-                unclear: "unclear";
-                other: "other";
-                bug_report: "bug_report";
-                feature_request: "feature_request";
-                praise: "praise";
-                complaint: "complaint";
-            }>, 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: "question" | "unclear" | "other" | "bug_report" | "feature_request" | "praise" | "complaint";
-            confidence: number;
-            probabilities: Record<"question" | "unclear" | "other" | "bug_report" | "feature_request" | "praise" | "complaint", number>;
-        }>;
-    };
-    'reply-template-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            templates: 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;
-            };
-        }>;
-    };
-};