jev-recipes 0.0.4 → 0.2.0

package/dist/catalog/groups/retrieval.js

@@ -0,0 +1,106 @@
+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

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