jev-recipes 0.0.4 → 0.2.0

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

@@ -0,0 +1,565 @@
+import type { RecipeOptions } from '../../src/schema.js';
+export declare const answersRecipes: {
+    'answer-coverage': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            draft: import("zod").ZodString;
+            questions: 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";
+            }>;
+            allAnswered: import("zod").ZodBoolean;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    partial: "partial";
+                    missing: "missing";
+                    unclear: "unclear";
+                    answered: "answered";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    partial: "partial";
+                    missing: "missing";
+                    unclear: "unclear";
+                    answered: "answered";
+                }>, 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";
+            allAnswered: boolean;
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "partial" | "missing" | "unclear" | "answered";
+                confidence: number;
+                probabilities: Record<"partial" | "missing" | "unclear" | "answered", number>;
+            }[];
+        }>;
+    };
+    'answer-relevance': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            draft: 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";
+                relevant: "relevant";
+                partly_relevant: "partly_relevant";
+                off_topic: "off_topic";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                relevant: "relevant";
+                partly_relevant: "partly_relevant";
+                off_topic: "off_topic";
+            }>, 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" | "relevant" | "partly_relevant" | "off_topic";
+            confidence: number;
+            probabilities: Record<"unclear" | "relevant" | "partly_relevant" | "off_topic", number>;
+        }>;
+    };
+    'citation-match': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+            uses: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            claim: import("zod").ZodString;
+            passages: 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";
+            }>;
+            passageIds: import("zod").ZodArray<import("zod").ZodString>;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    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>>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            passageIds: string[];
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "supported" | "contradicted" | "unsupported";
+                confidence: number;
+                probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
+            }[];
+        }>;
+    };
+    'citation-needed': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            statement: import("zod").ZodString;
+            citationRules: 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>;
+        }>;
+    };
+    'answer-consistency': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            firstStatement: import("zod").ZodString;
+            secondStatement: 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<{
+                conflicting: "conflicting";
+                unclear: "unclear";
+                consistent: "consistent";
+                unrelated: "unrelated";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                conflicting: "conflicting";
+                unclear: "unclear";
+                consistent: "consistent";
+                unrelated: "unrelated";
+            }>, 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" | "consistent" | "unrelated";
+            confidence: number;
+            probabilities: Record<"conflicting" | "unclear" | "consistent" | "unrelated", number>;
+        }>;
+    };
+    'summary-coverage': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            summary: import("zod").ZodString;
+            points: 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";
+            }>;
+            allPreserved: import("zod").ZodBoolean;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    partial: "partial";
+                    missing: "missing";
+                    unclear: "unclear";
+                    preserved: "preserved";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    partial: "partial";
+                    missing: "missing";
+                    unclear: "unclear";
+                    preserved: "preserved";
+                }>, 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";
+            allPreserved: boolean;
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "partial" | "missing" | "unclear" | "preserved";
+                confidence: number;
+                probabilities: Record<"partial" | "missing" | "unclear" | "preserved", number>;
+            }[];
+        }>;
+    };
+    'certainty-match': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            draft: import("zod").ZodString;
+            assessment: 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";
+                overstated: "overstated";
+                appropriate: "appropriate";
+                understated: "understated";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                overstated: "overstated";
+                appropriate: "appropriate";
+                understated: "understated";
+            }>, 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" | "overstated" | "appropriate" | "understated";
+            confidence: number;
+            probabilities: Record<"unclear" | "overstated" | "appropriate" | "understated", number>;
+        }>;
+    };
+    'promise-check': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            reply: import("zod").ZodString;
+            allowedCommitments: 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<{
+                unsupported: "unsupported";
+                unclear: "unclear";
+                within_commitments: "within_commitments";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unsupported: "unsupported";
+                unclear: "unclear";
+                within_commitments: "within_commitments";
+            }>, 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: "unsupported" | "unclear" | "within_commitments";
+            confidence: number;
+            probabilities: Record<"unsupported" | "unclear" | "within_commitments", number>;
+        }>;
+    };
+    'tone-check': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            draft: import("zod").ZodString;
+            criteria: 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";
+            }>;
+            allPassed: import("zod").ZodBoolean;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    unclear: "unclear";
+                    pass: "pass";
+                    fail: "fail";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    unclear: "unclear";
+                    pass: "pass";
+                    fail: "fail";
+                }>, 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";
+            allPassed: boolean;
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "unclear" | "pass" | "fail";
+                confidence: number;
+                probabilities: Record<"unclear" | "pass" | "fail", number>;
+            }[];
+        }>;
+    };
+    'draft-compare': {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "answer-quality";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            firstDraft: import("zod").ZodString;
+            secondDraft: import("zod").ZodString;
+            rubric: 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";
+                first: "first";
+                second: "second";
+                tie: "tie";
+                neither: "neither";
+            }>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                unclear: "unclear";
+                first: "first";
+                second: "second";
+                tie: "tie";
+                neither: "neither";
+            }>, 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" | "first" | "second" | "tie" | "neither";
+            confidence: number;
+            probabilities: Record<"unclear" | "first" | "second" | "tie" | "neither", number>;
+        }>;
+    };
+};

package/dist/catalog/groups/answers.js

@@ -0,0 +1,82 @@
+import { answerCoverage, answerCoverageInputSchema, answerCoverageResultSchema, } from '../../recipes/answer-coverage/index.js';
+import { metadata as answerCoverageMetadata } from '../../recipes/answer-coverage/metadata.js';
+import { answerRelevance, answerRelevanceInputSchema, answerRelevanceResultSchema, } from '../../recipes/answer-relevance/index.js';
+import { metadata as answerRelevanceMetadata } from '../../recipes/answer-relevance/metadata.js';
+import { citationMatch, citationMatchInputSchema, citationMatchResultSchema, } from '../../recipes/citation-match/index.js';
+import { metadata as citationMatchMetadata } from '../../recipes/citation-match/metadata.js';
+import { citationNeeded, citationNeededInputSchema, citationNeededResultSchema, } from '../../recipes/citation-needed/index.js';
+import { metadata as citationNeededMetadata } from '../../recipes/citation-needed/metadata.js';
+import { answerConsistency, answerConsistencyInputSchema, answerConsistencyResultSchema, } from '../../recipes/answer-consistency/index.js';
+import { metadata as answerConsistencyMetadata } from '../../recipes/answer-consistency/metadata.js';
+import { summaryCoverage, summaryCoverageInputSchema, summaryCoverageResultSchema, } from '../../recipes/summary-coverage/index.js';
+import { metadata as summaryCoverageMetadata } from '../../recipes/summary-coverage/metadata.js';
+import { certaintyMatch, certaintyMatchInputSchema, certaintyMatchResultSchema, } from '../../recipes/certainty-match/index.js';
+import { metadata as certaintyMatchMetadata } from '../../recipes/certainty-match/metadata.js';
+import { promiseCheck, promiseCheckInputSchema, promiseCheckResultSchema, } from '../../recipes/promise-check/index.js';
+import { metadata as promiseCheckMetadata } from '../../recipes/promise-check/metadata.js';
+import { toneCheck, toneCheckInputSchema, toneCheckResultSchema, } from '../../recipes/tone-check/index.js';
+import { metadata as toneCheckMetadata } from '../../recipes/tone-check/metadata.js';
+import { draftCompare, draftCompareInputSchema, draftCompareResultSchema, } from '../../recipes/draft-compare/index.js';
+import { metadata as draftCompareMetadata } from '../../recipes/draft-compare/metadata.js';
+export const answersRecipes = {
+    'answer-coverage': {
+        metadata: answerCoverageMetadata,
+        inputSchema: answerCoverageInputSchema,
+        resultSchema: answerCoverageResultSchema,
+        run: (input, options) => answerCoverage(answerCoverageInputSchema.parse(input), options),
+    },
+    'answer-relevance': {
+        metadata: answerRelevanceMetadata,
+        inputSchema: answerRelevanceInputSchema,
+        resultSchema: answerRelevanceResultSchema,
+        run: (input, options) => answerRelevance(answerRelevanceInputSchema.parse(input), options),
+    },
+    'citation-match': {
+        metadata: citationMatchMetadata,
+        inputSchema: citationMatchInputSchema,
+        resultSchema: citationMatchResultSchema,
+        run: (input, options) => citationMatch(citationMatchInputSchema.parse(input), options),
+    },
+    'citation-needed': {
+        metadata: citationNeededMetadata,
+        inputSchema: citationNeededInputSchema,
+        resultSchema: citationNeededResultSchema,
+        run: (input, options) => citationNeeded(citationNeededInputSchema.parse(input), options),
+    },
+    'answer-consistency': {
+        metadata: answerConsistencyMetadata,
+        inputSchema: answerConsistencyInputSchema,
+        resultSchema: answerConsistencyResultSchema,
+        run: (input, options) => answerConsistency(answerConsistencyInputSchema.parse(input), options),
+    },
+    'summary-coverage': {
+        metadata: summaryCoverageMetadata,
+        inputSchema: summaryCoverageInputSchema,
+        resultSchema: summaryCoverageResultSchema,
+        run: (input, options) => summaryCoverage(summaryCoverageInputSchema.parse(input), options),
+    },
+    'certainty-match': {
+        metadata: certaintyMatchMetadata,
+        inputSchema: certaintyMatchInputSchema,
+        resultSchema: certaintyMatchResultSchema,
+        run: (input, options) => certaintyMatch(certaintyMatchInputSchema.parse(input), options),
+    },
+    'promise-check': {
+        metadata: promiseCheckMetadata,
+        inputSchema: promiseCheckInputSchema,
+        resultSchema: promiseCheckResultSchema,
+        run: (input, options) => promiseCheck(promiseCheckInputSchema.parse(input), options),
+    },
+    'tone-check': {
+        metadata: toneCheckMetadata,
+        inputSchema: toneCheckInputSchema,
+        resultSchema: toneCheckResultSchema,
+        run: (input, options) => toneCheck(toneCheckInputSchema.parse(input), options),
+    },
+    'draft-compare': {
+        metadata: draftCompareMetadata,
+        inputSchema: draftCompareInputSchema,
+        resultSchema: draftCompareResultSchema,
+        run: (input, options) => draftCompare(draftCompareInputSchema.parse(input), options),
+    },
+};